Browse Source

Remove SLList.h

release/0.19
Jessica James 8 years ago
parent
commit
b8983d476a
  1. 1
      Jupiter/Jupiter.vcxproj
  2. 3
      Jupiter/Jupiter.vcxproj.filters
  3. 441
      Jupiter/SLList.h

1
Jupiter/Jupiter.vcxproj

@ -239,7 +239,6 @@
<ClInclude Include="SecureSocket.h" />
<ClInclude Include="Shift_String.h" />
<ClInclude Include="Shift_String_Imp.h" />
<ClInclude Include="SLList.h" />
<ClInclude Include="Socket.h" />
<ClInclude Include="String.h" />
<ClInclude Include="String_Imp.h" />

3
Jupiter/Jupiter.vcxproj.filters

@ -149,9 +149,6 @@
<ClInclude Include="DLList.h">
<Filter>Header Files\Lists</Filter>
</ClInclude>
<ClInclude Include="SLList.h">
<Filter>Header Files\Lists</Filter>
</ClInclude>
<ClInclude Include="UDPSocket.h">
<Filter>Header Files\Sockets</Filter>
</ClInclude>

441
Jupiter/SLList.h

@ -1,441 +0,0 @@
/**
* Copyright (C) 2013-2016 Jessica James.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Written by Jessica James <jessica.aj@outlook.com>
*/
#if !defined _SLLIST_H_HEADER
#define _SLLIST_H_HEADER
/**
* @file SLList.h
* @brief Provides a generic Singly Linked List implementation using the List interface.
*/
#include "Jupiter.h"
#include "List.h"
namespace Jupiter
{
/**
* @brief Provides a Singly Linked List implementation using the List interface.
*/
template<typename T> class SLList : public List<T>
{
public:
/**
* @brief Stores a pointer to data, and a pointer to the next node in the list.
*/
struct Node
{
Node *next = nullptr;
T *data = nullptr;
};
/*
* @brief Returns the head of the list
*
* @return Head of the list
*/
Node *getHead() const;
/*
* @brief Returns the tail of the list
*
* @return Tail of the list
*/
Node *getTail() const;
/**
* @brief Returns the Node at the specified index in the list.
*
* @param index Index of the node to return.
* @return Node at specified index in the list.
*/
Node *getNode(size_t index) const;
/**
* @brief Gets the data at a specified index.
*
* @param index Index of the data to get.
* @return Data stored at the specified index.
*/
T *get(size_t index) const;
/**
* @brief Removes the head of the list
*
* @return Value that was stored in the head of the list
*/
T *removeHead();
/**
* @brief Removes the n'th Node in the list, and returns its contents.
*
* @param n Index of the node to remove.
* @return Contents of the node removed.
*/
T *remove(size_t n);
/**
* @brief Removes the next node in the list.
*
* @param data Node that preceeds the node to be removed.
* @return Contents of the node removed if the node exists, nullptr otherwise.
*/
T *removeNext(Node *data);
/**
* @brief Adds data to the end of the list.
*
* @param data Data to add to the list.
*/
void add(T *data);
/**
* @brief Inserts data to the specified index in the list.
*
* @param data Data to insert into the list.
* @param index Position in the list to insert data to.
*/
void add(T *data, size_t index);
/**
* @brief Inserts data to the head of the list.
*
* @param data Data to insert into the list.
*/
void addHead(T *data);
/**
* @breif Erases all entries in the list
*/
void erase();
/**
* @breif Erases and deletes all entries in the list
*/
void eraseAndDelete();
SLList &operator=(const SLList &in_list);
SLList &operator=(SLList &&in_list);
/**
* @brief Default constructor for the SLList class.
*/
SLList() = default;
/**
* @brief Copy constructor for the SLList class.
*
* @param in_list List to copy data from
*/
SLList(const SLList<T> &in_list);
/**
* @brief Move constructor for the SLList class
*
* @param in_list List to move data from
*/
SLList(SLList<T> &&in_list);
/**
* @brief Destructor for the SLList class.
* Note: This does not delete data added to the list.
*/
~SLList();
/** Private members */
private:
void copy_from_internal(const SLList<T> &in_list);
Node *m_head = nullptr;
Node *m_tail = nullptr;
};
}
// Implementation
template<typename T> typename Jupiter::SLList<T>::Node *Jupiter::SLList<T>::getHead() const
{
return m_head;
}
template<typename T> typename Jupiter::SLList<T>::Node *Jupiter::SLList<T>::getTail() const
{
return m_tail;
}
template<typename T> typename Jupiter::SLList<T>::Node *Jupiter::SLList<T>::getNode(size_t in_index) const
{
if (in_index == Jupiter::SLList<T>::length)
return m_tail;
Jupiter::SLList<T>::Node *node = m_head;
while (in_index != 0)
{
node = node->next;
--in_index;
}
return node;
}
template<typename T> T *Jupiter::SLList<T>::get(size_t in_index) const
{
return Jupiter::SLList<T>::getNode(in_index)->data;
}
template<typename T> T *Jupiter::SLList<T>::removeHead()
{
if (m_head == nullptr)
return nullptr;
T *result = m_head->data;
Jupiter::SLList<T>::Node *node = m_head;
m_head = m_head->next;
delete node;
--Jupiter::List<T>::length;
return result;
}
template<typename T> T *Jupiter::SLList<T>::remove(size_t in_index)
{
if (in_index == 0)
return Jupiter::SLList<T>::removeHead();
Jupiter::SLList<T>::Node *node = m_head;
while (in_index != 1)
{
node = node->next;
--in_index;
}
Jupiter::SLList<T>::Node *tmp = node->next;
T *result = tmp->data;
node->next = tmp->next;
delete tmp;
--Jupiter::List<T>::length;
return result;
}
template<typename T> T *Jupiter::SLList<T>::removeNext(Node *in_data)
{
Jupiter::SLList<T>::Node *node = in_data->next;
if (node == nullptr)
return nullptr;
T *result = node->data;
in_data->next = node->next;
delete node;
--Jupiter::List<T>::length;
return result;
}
template<typename T> void Jupiter::SLList<T>::add(T *data)
{
Jupiter::SLList<T>::Node *node = new Jupiter::SLList<T>::Node();
node->data = data;
if (m_head == nullptr)
m_head = node;
else
m_tail->next = node;
m_tail = node;
++Jupiter::List<T>::length;
}
template<typename T> void Jupiter::SLList<T>::add(T *in_data, size_t in_index)
{
if (in_index == 0)
{
Jupiter::SLList<T>::addHead(in_data);
return;
}
if (in_index >= Jupiter::List<T>::length)
{
Jupiter::SLList<T>::add(in_data);
return;
}
Jupiter::SLList<T>::Node *node = new Jupiter::SLList<T>::Node();
node->data = in_data;
Jupiter::SLList<T>::Node *itr = m_head;
while (in_index != 1)
{
itr = itr->next;
--in_index;
}
node->next = itr->next;
itr->next = node;
++Jupiter::List<T>::length;
}
template<typename T> void Jupiter::SLList<T>::addHead(T *data)
{
Jupiter::SLList<T>::Node *node = new Jupiter::SLList<T>::Node();
node->data = data;
node->next = m_head;
m_head = node;
if (m_tail == nullptr)
m_tail = node;
++Jupiter::List<T>::length;
}
template<typename T> void Jupiter::SLList<T>::erase()
{
Jupiter::SLList<T>::Node *node = m_head;
if (node == nullptr)
return;
Jupiter::SLList<T>::Node *tmp;
do
{
tmp = node;
node = node->next;
delete tmp;
} while (node != nullptr);
m_head = nullptr;
m_tail = nullptr;
Jupiter::List<T>::length = 0;
}
template<typename T> void Jupiter::SLList<T>::eraseAndDelete()
{
Jupiter::SLList<T>::Node *node = m_head;
if (node == nullptr)
return;
Jupiter::SLList<T>::Node *tmp;
do
{
tmp = node;
node = node->next;
delete tmp->data;
delete tmp;
} while (node != nullptr);
m_head = nullptr;
m_tail = nullptr;
Jupiter::List<T>::length = 0;
}
template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::SLList>
{
template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::SLList<Y> *data)
{
buffer->push<size_t>(data->size());
Jupiter::SLList<Y>::Node *head = data->getHead();
while (head != nullptr)
buffer->push<Y>(*head++->data);
};
template<typename Y> static Jupiter::SLList<Y> interpret(uint8_t *&head)
{
size_t size_ = *reinterpret_cast<size_t *>(head);
head += sizeof(size_t);
Jupiter::SLList<Y> r;
while (size_-- != 0)
r.add(Jupiter::DataBuffer::interpret_data<Y>(head));
return r;
}
};
template<typename T> Jupiter::SLList<T> &Jupiter::SLList<T>::operator=(const SLList &in_list)
{
Jupiter::SLList<T>::erase();
Jupiter::SLList<T>::copy_from_internal(in_list);
return *this;
}
template<typename T> Jupiter::SLList<T> &Jupiter::SLList<T>::operator=(SLList &&in_list)
{
m_head = in_list.m_head;
m_tail = in_list.m_tail;
return *this;
}
template<typename T> Jupiter::SLList<T>::SLList(const Jupiter::SLList<T> &in_list)
{
Jupiter::SLList<T>::copy_from_internal(in_list);
}
template<typename T> Jupiter::SLList<T>::SLList(Jupiter::SLList<T> &&in_list)
{
m_head = in_list.m_head;
m_tail = in_list.m_tail;
in_list.m_head = nullptr;
in_list.m_tail = nullptr;
}
template<typename T> Jupiter::SLList<T>::~SLList()
{
Jupiter::SLList<T>::erase();
}
/** Internal */
template<typename T> void Jupiter::SLList<T>::copy_from_internal(const SLList<T> &in_list)
{
Jupiter::SLList<T>::Node *source_node = in_list.m_head;
if (source_node == nullptr)
return;
Jupiter::SLList<T>::Node *node = new Jupiter::SLList<T>::Node();
node->data = source_node->data;
source_node = source_node->next;
while (source_node != nullptr)
{
node->next = new Jupiter::SLList<T>::Node();
node = node->next;
node->data = source_node->data;
source_node = source_node->next;
}
m_tail = node;
Jupiter::List<T>::length = in_list.length;
}
#endif // _SLLIST_H_HEADER
Loading…
Cancel
Save