#include "Node.h"
#include "TempLinkedList.h"
template<typename T>
void Testone()
{
	TempLinkedList* list = new TempLinkedList();

	TempNode* m_head1 = new TempNode("2");
	TempNode* m_head2 = new TempNode("4");
	TempNode* m_head3 = new TempNode("6");
	TempNode* m_head4 = new TempNode("8");
	TempNode* m_head5 = new TempNode("10");
	TempNode* m_head6 = new TempNode("12");
	list->PushBack(m_head1);
	list->PushBack(m_head2);
	list->PushBack(m_head3);
	list->PushBack(m_head4);
	list->PushBack(m_head5);
	list->PushBack(m_head6);
	list->Execute();

}
template<typename T>
void main()
{
	Testone<T>(); // Testone isn't coloured in like the rest of the code so 
                      //I suspect that's where the problem is really going 
                      //wrong. I don't know why though.
	TempNode<T> TTempNode;
	T numAdd = TTempNode.GetNext();

	system("pause");
}

#pragma once
#include <iostream>
#include "Node.h"
template<typename T>
class TempLinkedList
{
public:
	TempLinkedList();
	TempNode<T>* GetHead();

	void PushBack(T data, T m_node);

	void Execute();

private:
	T* m_head;
};

template<typename T>
TempLinkedList<T>::TempLinkedList()
{
	m_head = nullptr;
}

template<typename T>
inline TempNode<T>* TempLinkedList<T>::GetHead()
{
	return m_head;
}



template<typename T>
void TempLinkedList<T>::PushBack(T data, T m_node)
{
	TempNode* temp = m_head;
	if (m_head == nullptr)
	{
		m_head = m_node; 
		return;
	}
	while (temp->GetNext() != nullptr)
	{
		temp = temp->GetNext();
	}
	temp->SetNext(m_node); 
}

template<typename T>
void TempLinkedList<T>::Execute()
{
	TempNode* temp = m_head;
	while (temp != nullptr)
	{
		temp->Execute();
		temp = temp->GetNext();
	}
}

#pragma once
#include <string>
#include <iostream>
using namespace std;
template<typename T>
class TempNode
{
public:
	TempNode(string* data, int* m_node)
	{
			data = new T[];
	}
	

	TempNode(T data, T next, T m_node);
	~TempNode();

	void SetNext(T* next);
	T* GetNext();
	T GetData();

	void execute();
private:
	T data;
	T next;
	T m_node;
	T TTempNode;

};

template<typename T>
TempNode<T>::TempNode(T data, T next, T m_node)
{
	this->data = data;
	this->next = nullptr;
	this->m_node = m_node;
}

template<typename T>
TempNode<T>::~TempNode()
{
}

template<typename T>
T* TempNode<T>::GetNext()
{
	return next;
}

template<typename T>
void TempNode<T>::SetNext(T* next)
{
	this->next = next;
}

template<typename T>
T TempNode<T>::GetData()
{
	return data;
}

template<typename T>
void TempNode<T>::execute()
{
	std::cout << data << std::endl;
}

#include <iostream>
#include <string>

template < typename T > struct list // assumption: T is copy consructible ie. template < std::copy_constructible T >
{

    list() = default ; // initialise head and tail to nullptr
    ~list() { while( !empty() ) pop_front() ; } // release owned resources (nodes) on destruction

    bool empty() const noexcept { return head == nullptr ; }

    void push_back( const T& v )
    {
        if( empty() ) head = tail = new node(v) ;
        else
        {
            tail->next = new node(v) ;
            tail = tail->next ;
        }
    }

    void pop_front() noexcept
    {
        if( !empty() )
        {
            node* t = head ;
            head = head->next ;
            if( empty() ) tail = nullptr ;
            delete t ;
        }
    }

    void print( std::ostream& stm = std::cout ) const
    {
        std::size_t slno = 0 ; // zero-based serial number
        for( const node* n = head ; n != nullptr ; n = n->next )
            stm << "(#" << slno++ << "). " << n->data << " => " ;

        stm << "nullptr\n" ;
    }

    private:

        struct node // node is an implementation detail
        {
            T data ;
            node* next ;
            explicit node( const T& data, node* next = nullptr ) : data(data), next(next) {}
        };

        node* head = nullptr ;
        node* tail = nullptr ;

        // non-copyable and non-asignable (for now)
        list( const list& ) = delete ;
        list& operator= ( const list& ) = delete ;
};

// test list of T by inserting items from the input range one by one,
// and then removing items one by one till the list is empty
// assumption: input range contains a sequence of values which can be implicitly converted to T
// ie. template < typename T, std::ranges::input_range INPUT_RANGE > requires std::constructible_from< T, std::ranges::range_value_t<INPUT_RANGE> >
template < typename T, typename INPUT_RANGE > void test( const INPUT_RANGE& input_range )
{
     std::cout << "\n-----------------------------------------\n" ;

     list<T> lst ; // there is no good reason to create the list using new

     for( const auto& v : input_range )
     {
         lst.push_back(v) ;
         lst.print() ;
     }

     std::cout << '\n' ;

     while( !lst.empty() )
     {
         lst.pop_front() ;
         lst.print() ;
     }

     std::cout << "\n-----------------------------------------\n" ;
}

int main()
{
    const int a[] { 123, 234, 345, 456, 567, 678, 789 } ;
    test<int>(a) ;

    const char* const b[] { "cero", "uno", "dos", "tres", "cuatro", "cinco" } ;
    test<std::string>(b) ; // can convert const char* to std::string
}