Method (member function) SinglyLinkedList::insertAfter(), takes two parameters: a pointer (curNode) and a value (newData), defined in:

#pragma once
	#include
	template
	struct Node {
	T data;
	Node* next;
	Node() = delete; // Intentionally no default constructor
	Node( const T & element ) : data( element ), next( nullptr ) {}
	};
	template
	class SinglyLinkedList {
	private:
	Node* head;
	Node* tail;
	public:
	// Constructors
	SinglyLinkedList();
	SinglyLinkedList(const SinglyLinkedList&);
	SinglyLinkedList& operator=(const SinglyLinkedList&); // assignment operator
	~SinglyLinkedList(); // destructor
	// Getters / Setters
	bool empty();
	int size() = delete; // INTENTIONALLY NOT IMPLEMENTED !!
	void append( const T& );
	void prepend( const T& );
	void insertAfter( Node*, const T& );
	void removeAfter( Node* );
	void pop_front(); // remove element at front of list
	T& front(); // return list's front element
	T& back(); // return list's back element
	void clear();
	};
	template
	SinglyLinkedList::SinglyLinkedList() : head( nullptr ), tail( nullptr ) {}
	template
	bool SinglyLinkedList::empty() {
	return head == nullptr;
	}
	template
	void SinglyLinkedList::append( const T& newData ) {
	Node * newNode = new Node( newData ); // create new node
	if (head == nullptr) { // List empty
	head = newNode;
	tail = newNode;
	}
	else{
	tail->next = newNode;
	tail = newNode;
	}
	}
	template
	void SinglyLinkedList::prepend( const T& newData ) {
	Node * newNode = new Node( newData ); // create new node
	if (head == nullptr) { // list empty
	head = newNode;
	tail = newNode;
	}
	else {
	newNode->next = head;
	head = newNode;
	}
	}
	template
	void SinglyLinkedList::insertAfter(Node* curNode, const T& newData) {
	// Construct new node
	Node* newNode = new Node( newData );
	if (head == nullptr) { // List empty
	head = newNode;
	tail = newNode;
	} else if (curNode == tail) { // Insert after tail
	tail->next = newNode;
	tail = newNode;
	} else {
	newNode->next = curNode->next;
	curNode->next = newNode;
	}
	}
	template
	void SinglyLinkedList::removeAfter(Node* curNode) {
	if( empty() ) throw std::length_error( "empty list" );
	// Special case, remove head
	if (curNode == nullptr && head != nullptr) {
	Node *sucNode = head->next;
	head = sucNode;
	if (sucNode == nullptr) { // Removed last item
	tail = nullptr;
	}
	}
	else if (curNode->next != nullptr) {
	Node *sucNode = curNode->next->next;
	curNode->next = sucNode;
	if (sucNode == nullptr) { // Removed tail
	tail = curNode;
	}
	}
	}
	template
	void SinglyLinkedList::pop_front() {
	removeAfter(nullptr);
	}
	template
	T& SinglyLinkedList::front() {
	if( empty() ) throw std::length_error( "empty list" );
	return head->data;
	}
	template
	T& SinglyLinkedList::back() {
	if( empty() ) throw std::length_error( "empty list" );
	return tail->data;
	}
	template
	void SinglyLinkedList::clear() {
	while( !empty() )
	pop_front();
	}
	template
	SinglyLinkedList::~SinglyLinkedList() {
	clear();
	}
	template
	SinglyLinkedList::SinglyLinkedList( const SinglyLinkedList & original ) : SinglyLinkedList() {
	// Walk the original list adding copies of the elements to this list maintaining order
	for( Node * position = original.head; position != nullptr; position = position->next ) {
	append( position->data );
	}
	}
	template
	SinglyLinkedList & SinglyLinkedList::operator=( const SinglyLinkedList & rhs ) {
	if( this != &rhs ) // avoid self assignment
	{
	// Release the contents of this list first
	clear(); // An optimization might be possible by reusing already allocated nodes
	// Walk the right hand side list adding copies of the elements to this list maintaining order
	for( Node * position = rhs.head; position != nullptr; position = position->next ) {
	append( position->data );
	}
	}
	return *this;
	}

1. What does the method do if curNode == nullptr but head is not null? (Answer in 1-2 sentences. Be specific: refer to specific lines in the code as necessary.)

2. Modify the method such that when curNode == nullptr, the function will insert the value (newData) at the front of the linked list. Write the modified method.