imk0tter

Untitled

Aug 2nd, 2021
913
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /// SMObjects.h
  2. #pragma once
  3.  
  4. #include <string>
  5.  
  6. #include <map>
  7. #include <vector>
  8.  
  9. namespace SMObjects {
  10.     template<typename VALUE>
  11.     class ListEntry {
  12.     public:
  13.         VALUE * m_Value;
  14.  
  15.         bool operator==(const ListEntry<VALUE>& comparator)
  16.         {
  17.             return m_Value == comparator.m_Value;
  18.         }
  19.         bool operator==(const VALUE& value)
  20.         {
  21.             return m_Value == &value;
  22.         }
  23.         ListEntry(VALUE & value)
  24.         {
  25.             m_Value = &value;
  26.         }
  27.         ~ListEntry();
  28.     };
  29.  
  30.  
  31.     template<typename VALUE>
  32.     class List {
  33.  
  34.  
  35.         int                         m_MaxChunkSize;
  36.         int                         m_CurrentChunkSize;
  37.  
  38.         int                         m_EntryCount;
  39.  
  40.         bool                        _CreateChunk();
  41.         VALUE**                     m_ChunkArray;
  42.     public:
  43.         static const int&           DEFAULT_CHUNK_COUNT;
  44.  
  45.                                     List(int DEFAULT_CHUNK_COUNT);
  46.                                     List();
  47.  
  48.                                     ~List();
  49.  
  50.                                     int                         Count();
  51.         void                        Add(const VALUE& value);
  52.  
  53.         bool                        Remove(int index);
  54.         bool                        Remove(const VALUE& value, bool all = false);
  55.  
  56.         bool                        Insert(const VALUE& value, int index);
  57.  
  58.         int                         Find(const VALUE& value, int startPos);
  59.         int                         Find(const VALUE& value);
  60.         VALUE &                     Get(int index);
  61.         //vector<VALUE*>                Get();
  62.  
  63.         void                        Clear();
  64.        
  65.  
  66.         VALUE&                      operator[] (int index);
  67.         //int                           operator[] (const VALUE& value);
  68.  
  69.         VALUE&                      operator* () { return **m_ChunkArray; }
  70.         void                        operator++ () { ++m_ChunkArray; }
  71.  
  72.         VALUE**                     begin() { return m_ChunkArray; }
  73.         VALUE**                     end() { return m_ChunkArray + m_EntryCount; }
  74.     };
  75. }
  76.  
  77. ///SMObjects.cpp
  78. #include "SMObjects.h"
  79.  
  80. #include <vector>
  81. #include <map>
  82.  
  83. using namespace std;
  84.  
  85. namespace SMObjects {
  86.     /// <summary>
  87.     /// Class 'List' Implementation
  88.     /// </summary>
  89.     /// <typeparam name="VALUE"></typeparam>
  90.     /// <param name="DEFAULT_CHUNK_COUNT"></param>
  91.     template<typename VALUE>
  92.     List<VALUE>::List(int DEFAULT_CHUNK_COUNT)
  93.     {
  94.         this->DEFAULT_CHUNK_COUNT = DEFAULT_CHUNK_COUNT;
  95.         _CreateChunk();
  96.     }
  97.  
  98.     template<typename VALUE>
  99.     List<VALUE>::List() : List(128)
  100.     {
  101.     }
  102.  
  103.     template<typename VALUE>
  104.     int List<VALUE>::Count()
  105.     {
  106.         return m_EntryCount;
  107.     }
  108.  
  109.     template<typename VALUE>
  110.     bool List<VALUE>::_CreateChunk()
  111.     {
  112.         if (m_EntryCount >= m_CurrentChunkSize)
  113.         {
  114.             m_CurrentChunkSize += DEFAULT_CHUNK_COUNT;
  115.  
  116.             if (m_CurrentChunkSize > m_MaxChunkSize)
  117.             {
  118.                 VALUE ** newChunkArray = new VALUE*[m_CurrentChunkSize];
  119.  
  120.                 memcpy(newChunkArray, m_ChunkArray, sizeof(m_ChunkArray));
  121.  
  122.                 delete[] m_ChunkArray;
  123.  
  124.                 m_ChunkArray = newChunkArray;
  125.                 return true;
  126.             }
  127.         }
  128.         return false;
  129.     }
  130.  
  131.     template<typename VALUE>
  132.     List<VALUE>::~List()
  133.     {
  134.         for (VALUE* currentListEntry : m_ChunkArray)
  135.         {
  136.             //delete currentListEntry->m_Value;
  137.             //delete currentListEntry;
  138.         }
  139.         delete[] m_ChunkArray;
  140.     }
  141.  
  142.     template<typename VALUE>
  143.     VALUE& List<VALUE>::operator[] (int index)
  144.     {
  145.         return Get(index);
  146.     }
  147.  
  148.     template<typename VALUE>
  149.     bool List<VALUE>::Insert(const VALUE& value, int index)
  150.     {
  151.         if (index < m_EntryCount)
  152.         {
  153.             ++m_EntryCount;
  154.             _CreateChunk();
  155.  
  156.             VALUE ** start = m_ChunkArray[index];
  157.             VALUE ** end = m_ChunkArray[m_EntryCount - 1];
  158.  
  159.             int size = end - start;
  160.  
  161.             if (size > 0) memcpy(start + 1, start, size);
  162.  
  163.             m_ChunkArray[index] = &value;
  164.  
  165.             return true;
  166.         }
  167.         return false;
  168.     }
  169.     template<typename VALUE>
  170.     void List<VALUE>::Add(const VALUE& value)
  171.     {
  172.         int index = m_EntryCount++;
  173.  
  174.         if (_CreateChunk())
  175.         {
  176.             //DEBUG NEW CHUNK CREATION
  177.         }
  178.  
  179.         m_ChunkArray[index] = &value;
  180.     }
  181.  
  182.     template<typename VALUE>
  183.     bool List<VALUE>::Remove(int index)
  184.     {
  185.         if (index <= m_EntryCount)
  186.         {
  187.             VALUE ** _begin = m_ChunkArray[index];
  188.             delete* _begin;
  189.  
  190.             VALUE ** _end = m_ChunkArray[--m_EntryCount];
  191.  
  192.             int size = _end - _begin;
  193.             memcpy(_begin, _end, size);
  194.  
  195.             return true;
  196.         }
  197.         else
  198.         {
  199.             return false;
  200.         }
  201.     }
  202.  
  203.     template<typename VALUE>
  204.     bool List<VALUE>::Remove(const VALUE& value, bool all)
  205.     {
  206.         int f = 0;
  207.         int removeCount = 0;
  208.         if (all) {
  209.             while (f = Find(value, f) >= 0)
  210.             {
  211.                 Remove(f);
  212.                 ++removeCount;
  213.             }
  214.             return removeCount > 0;
  215.         }
  216.         if (f = Find(value, f) >= 0)
  217.         {
  218.             Remove(f);
  219.             return true;
  220.         }
  221.         return false;
  222.     }
  223.     template<typename VALUE>
  224.     int List<VALUE>::Find(const VALUE& value)
  225.     {
  226.         return Find(value, 0);
  227.     }
  228.  
  229.     template<typename VALUE>
  230.     int List<VALUE>::Find(const VALUE& value, int startPos)
  231.     {
  232.         for (int i = startPos; i < m_ChunkArray; ++i)
  233.         {
  234.             if (value == *m_ChunkArray[i])
  235.             {
  236.                 return i;
  237.             }
  238.         }
  239.         return -1;
  240.     }
  241.     template<typename VALUE>
  242.     VALUE & List<VALUE>::Get(int index)
  243.     {
  244.         if (index < m_EntryCount)
  245.         {
  246.             return **m_ChunkArray[index];
  247.         }
  248.         return NULL;
  249.     }
  250.  
  251.     template<typename VALUE>
  252.     void List<VALUE>::Clear()
  253.     {
  254.         m_EntryCount = 0;
  255.         m_CurrentChunkSize = 0;
  256.     }
  257. }
  258.  
  259. // SMTesting.cpp : This file contains the 'main' function. Program execution begins and ends there.
  260. //
  261.  
  262. #include <iostream>
  263.  
  264. #include "SMObjects.h"
  265.  
  266. using namespace SMObjects;
  267.  
  268. using namespace std;
  269.  
  270. int main()
  271. {
  272.     List<int*>* someList = new List<int*>(16);
  273.  
  274.     for (int i = 0; i < 12; ++i)
  275.     {
  276.         someList->Add(new int(3 * i));
  277.     }
  278.  
  279.     for (int i = 0; i < someList->Count(); ++i)
  280.     {
  281.         cout << "Current List Number :" << i << ", Current List Value: " << *someList->Get(i) << "\n";
  282.     }
  283.  
  284.     while (someList->Count() > 0) {
  285.         delete someList->Get(0);
  286.         someList->Remove(0);
  287.     }
  288.  
  289.     for (int i = 0; i < 38; ++i)
  290.     {
  291.         someList->Add(new int(98349834 % i));
  292.     }
  293.  
  294.     for (int i = 0; i < someList->Count(); ++i)
  295.     {
  296.         cout << "Current List Number :" << i << ", Current List Value: " << *someList->Get(i) << "\n";
  297.         //delete someList->Get(i);
  298.     }
  299.  
  300.  
  301.     someList->Clear();
  302.  
  303.  
  304.     someList->Insert(new int(1337), 16);
  305.  
  306.     for (int i = 0; i < someList->Count(); ++i)
  307.     {
  308.         cout << "Current List Number :" << i << ", Current List Value: " << *someList->Get(i) << "\n";
  309.         delete someList->Get(i);
  310.     }
  311.  
  312.     someList->Clear();
  313.  
  314.     delete someList;
  315.  
  316. }
  317.  
RAW Paste Data