linkedlist.cpp

finite element mesh 参数化有限元网格划分

	/** Remove all elements in the list between the element pointed by \e iterBegin, and the element pointed by \e iterEnd (including both). 
		\param iterBegin An iterator pointing to the first element to erase  
		\param iterEnd An iterator pointing to the last element to erase  
		\retval true Elements removed succesfully  
		\retval false Operation failed (\e iterBegin or \e iterEnd were not pointing to valid elements) 
	*/
	bool erase(iterator iterBegin, iterator iterEnd) {
		if (iterBegin.ptr==NULL || iterEnd.ptr==NULL) return false;
		iterator iter, iter1;
		for (iter = iterBegin; iter!=iterEnd; ) {
			iter1=iter++;
			erase(iter1);
		}
		erase(iter);
		return true;
	}
	/** Remove all the elements in the list whose value is equal to the given value. 
		\param value The value to remove from the list  
		\retval true Operation succeeded  
		\retval false No element was removed (none with the given value) 
	*/
	bool remove(const T& value) {
		iterator endIter = end();
		bool removed = false;
		for (iterator iter = begin(); iter != endIter; ) {
			if (*iter == value) {
				erase(iter++);
				removed = true;
			}
			else
				++iter; 
		}
		return removed;
	}
	/** Remove all the elements in the list whose value is equal to the given value, and count the number of elements removed. 
		\param value The value to remove from the list  
		\param count \out The number of elements removed from the list  
		\retval true Operation succeeded  
		\retval false No element was removed (none with the given value) 
	*/
	bool removeAndCount(const T& value, long &count) {
		iterator endIter = end();
		count = 0;
		bool removed = false;
		for (iterator iter = begin(); iter != endIter; ) {
			if (*iter == value) {
				erase(iter++);
				removed = true;
				count++;
			}
			else
				++iter; 
		}
		return removed;
	}
	/** Copies the given list at the end of the current list. 
		\param list The list to copy  
		\retval true Operation succeeded  
		\retval false Operation failed (\e list is NULL) 
	*/
	bool push_back_list(LinkedList<T> *list) {
		LinkedList<T>::iterator iter;
		T element;
		for (iter = list->begin(); iter!=list->end(); iter++) {
			element = (T)(*iter);
			this->push_back(element);
		}
		return true;
	}
	/** Insert a new element with the given value to the head of the list. 
		\param value The value of the element to add  
		\retval true Operation succeeded  
		\retval false Operation failed 
	*/
	bool push_front(const T& value) {
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->next = head->next;
		newElement->next->prev = newElement;
		newElement->prev = head;
		newElement->prev->next = newElement;
		Size++;
		return true;
	}

	/** Insert a new element with the given value to the end of the list. 
		\param value The value of the element to add  
		\retval true Operation succeeded  
		\retval false Operation failed 
	*/
	bool push_back(const T& value) {
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->prev = tail->prev;
		newElement->prev->next = newElement;
		newElement->next = tail;
		newElement->next->prev = newElement;
		Size++;
		return true;
	}
	/** Insert a new element with the given value to the head of the list, only if the same value is not already contained in the list. 
		\param value The value of the element to add  
		\retval true Operation succeeded (element added)  
		\retval false Operation failed (\e value already exists in the list) 
	*/
	bool push_front_unique(const T& value) {
		if (contains(value))
			return false;
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->next = head->next;
		newElement->next->prev = newElement;
		newElement->prev = head;
		newElement->prev->next = newElement;
		Size++;
		return true;
	}
	/** Insert a new element with the given value to the end of the list, only if the same value is not already contained in the list. 
		\param value The value of the element to add  
		\retval true Operation succeeded (element added)  
		\retval false Operation failed (\e value already exists in the list) 
	*/
	bool push_back_unique(const T& value) {
		if (contains(value))
			return false;
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->prev = tail->prev;
		newElement->prev->next = newElement;
		newElement->next = tail;
		newElement->next->prev = newElement;
		Size++;
		return true;
	}

	/** Remove the first element of the list and return it. 
		If the list is already empty, the function fails and calls exit(1) (after printing an error message) 
		\return The value of the first element of the list (which was removed)
	*/
	T pop_front() {
		if (Size>0) {
			ListElement<T>* removeElement = head->next;
			T removeVal = removeElement->value;
			head->next = removeElement->next;
			removeElement->next->prev =	head;
			delete removeElement;
			Size--;
			return removeVal;
		}
		else {
			MessageBox(NULL,"LinkedList::pop_front - no element to pop, exiting ...\n", "Error", MB_OK);
			exit(1);
		}
	}
	/** Remove the last element of the list and return it. 
		If the list is already empty, the function fails and calls exit(1) (after printing an error message) 
		\return The value of the last element of the list (which was removed)
	*/
	T pop_back() {
		if (Size>0) {
			ListElement<T>* removeElement = tail->prev;
			T removeVal = removeElement->value;
			tail->prev = removeElement->prev;
			removeElement->prev->next =	tail;
			delete removeElement;
			Size--;
			return removeVal;
		}
		else {
			MessageBox(NULL,"LinkedList::pop_back - no element to pop, exiting ...\n", "Error", MB_OK);
			exit(1);
		}
	}
	/** Returns the first element of the list (without removing it). 
		If the list is empty, the function fails and calls exit(1) 
		\return A reference of the first element of the list
	*/
	T& front() {
		if (Size>0)
			return head->next->value;
		else {
			MessageBox(NULL,"LinkedList::front - list is empty, exiting ...\n", "Error", MB_OK);
			exit(1);
		}
	}
	/** Returns the last element of the list (without removing it). 
		If the list is empty, the function fails and calls exit(1) 
		\return A reference of the last element of the list
	*/
	T& back() {
		if (Size>0)
			return tail->prev->value;
		else {
			MessageBox(NULL,"LinkedList::back - list is empty, exiting ...\n", "Error", MB_OK);
			exit(1);
		}
	}

	/** Returns an iterator pointing to the first element of the list. 
		\return An iterator pointing to first element of the list 
		\sa Usage for begin() and end() in the documentation for LinkedList::iterator
	*/
	iterator begin() {
		iterator iter(head->next);
		return iter;
	}

	/** Returns an iterator pointing to a dummy element, which is an element after the last element of the list. 
		\return An iterator pointing to first element of the list 
		\sa Usage for begin() and end() in the documentation for LinkedList::iterator
	*/
	iterator end() {
		iterator iter(tail);
		return iter;
	}

	/** Inserts a new element with the given value to the list, after the element pointed to by \e iter. 
		\param iter The iterator after which the element should be added  
		\param value The value to add  
		\return If \e iter is NULL, the value is not inserted and the function returns NULL; else, the function returns an iterator pointing to the element holding the new value
	*/
	iterator* insertAfter(iterator* iter, const T& value) {
		if (iter==NULL)
			return NULL;
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->next = iter->ptr->next;
		newElement->next->prev = newElement;
		newElement->prev = iter->ptr;
		newElement->prev->next = newElement;
		Size++;
		iterator* newIter = new iterator(newElement);
		return newIter;
	}

	/** Inserts a new element with the given value to the list, before the element pointed to by \e iter. 
		\param iter The iterator after which the element should be added  
		\param value The value to add  
		\return If \e iter is NULL, the value is not inserted and the function returns NULL; else, the function returns an iterator pointing to the element holding the new value 
	*/
	iterator* insertBefore(iterator* iter, const T& value) {
		if (iter==NULL)
			return NULL;
		ListElement<T>* newElement = new ListElement<T>(value);
		newElement->prev = iter->ptr->prev;
		newElement->prev->next = newElement;
		newElement->next = iter->ptr;
		newElement->next->prev = newElement;
		Size++;
		iterator* newIter = new iterator(newElement);
		return newIter;
	}

};

#endif