q3k
/
Cucumber
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring code.

alentours-dev
Sergiusz Bazanski 2011-05-08 17:16:00 +02:00
parent 028842d07d
commit 11cf26eb54
25 changed files with 54 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/Tier1/CInterruptDispatcher.h
View File

@ -17,7 +17,6 @@ extern "C" {
//CInterruptDispatcher StaticDispatcher Implementation
#define CID_SDIS_IMP(n) void CInterruptDispatcher::d_Interrupt##n( \
T_ISR_REGISTERS_ERR R) { \
kprintf("oioi\naaaa\nbbbbb\n"); \
if (m_Dispatchers[n] != 0) \
m_Dispatchers[n]->Dispatch(&R); \
}
@ -36,7 +35,7 @@ namespace cb {
u8 m_Interrupt;
// Enabled?
bool m_Enabled;
bool m_bEnabled;
// Private enable function - call it from the constructor, another
// public method or whatever
@ -47,7 +46,7 @@ namespace cb {
private:
// Internal stuff for translating static calls into member functions
static CInterruptDispatcher *m_Dispatchers[256];
static bool m_InitializedStatic;
static bool m_bInitializedStatic;
static void InitializeStatic(void);
// All the static dispatchers for all the interrupts

5
include/Tier1/CKernel.h
View File

@ -3,13 +3,11 @@
#include "types.h"
#include "Tier1/CLogger.h"
#include "Tier1/Drivers/CDriverManager.h"
#include "Tier1/CTask.h"
#define CKERNEL_MAGIC 0x8BA67FE9
namespace cb {
class CDriverManager;
class CTask;
class CKernel {
public:
@ -18,9 +16,8 @@ namespace cb {
CLogger &Logger(void);
private:
u32 m_Magic;
u32 m_dwMagic;
CLogger *m_Logger;
CDriverManager *m_DriverManager;
CTask *CreateKernelTask(void);
};

2
include/Tier1/CPageDirectory.h
View File

@ -29,7 +29,7 @@ namespace cb {
void CreateTable(u32 Virtual, u8 User = 1, u8 RW = 1);
// Whether it was created empty
bool m_CreatedEmpty;
bool m_bCreatedEmpty;
public:
// Creates a new page directory for a kernel task
CPageDirectory(bool Empty = false);

4
include/Tier1/CRoundRobinScheduler.h
View File

@ -11,11 +11,11 @@ namespace cb {
void AddTask(CTask *Task);
void NextTask(void);
CTask *GetCurrentTask(void);
void DispatchAvailableSemaphore(CSemaphore *Semaphore);
void SetSemaphoreAvailable(CSemaphore *Semaphore);
private:
CTask *m_CurrentTask;
CLinearList<CTask *> m_TaskQueue;
u32 m_TaskQueuePosition;
u32 m_iTaskQueuePosition;
};
};

2
include/Tier1/CTask.h
View File

@ -161,7 +161,7 @@ namespace cb {
void Dump(void);
void CedeTimeSlice(void);
void Yield(void);
void WaitForSemaphore(T_SEMAPHORE *Semaphore);
void WaitForSemaphore(CSemaphore *Semaphore);

8
include/Tier1/CTimer.h
View File

@ -20,16 +20,16 @@ namespace cb {
u32 Extra = 0);
inline static u32 GetTicks(void)
{
if (!m_Initialized)
if (!m_bInitialized)
Initialize();
return m_NumTicks;
return m_nTicks;
}
private:
static CLinearList<TCallbackInfo> m_Callbacks;
volatile static u32 m_NumTicks;
volatile static u32 m_nTicks;
static void Initialize(void);
static void Dispatch(void *Registers);
static bool m_Initialized;
static bool m_bInitialized;
// Called when the number of ticks is just about to overflow.
// Reschedules all the callbacks.

37
include/Tier1/Drivers/CDriverManager.h
View File

@ -1,37 +0,0 @@
#ifndef __CDRIVERMANAGER_H__
#define __CDRIVERMANAGER_H__
#include "types.h"
#include "Tier1/Drivers/IDriver.h"
#include "Tier1/CKernel.h"
namespace cb {
class IDriver;
class CKernel;
typedef struct {
IDriver *Driver;
bool New;
bool Loaded;
bool Present;
} CDriverManagerEntry;
class CDriverManager {
public:
CDriverManager(u32 MaxDrivers, CKernel *Kernel);
void AddDriver(IDriver *Driver);
void LoadDriver(s8 *Name);
void LoadAll(void);
void LoadNew(void);
void UnloadDriver(s8 *Name);
private:
CDriverManagerEntry *m_aDrivers;
u32 m_nMaxDrivers;
CKernel *m_Kernel;
void LoadDriver(u32 Index);
};
};
#endif

23
include/Tier1/Drivers/Device/CDriverRamdisk.h
View File

@ -1,23 +0,0 @@
#ifndef __CDRIVERRAMDISK_H__
#define __CDRIVERRAMDISK_H__
#include "Tier1/Drivers/IDriver.h"
#include "Tier1/Drivers/IDevice.h"
#include "Tier1/CKernel.h"
namespace cb {
class CDriverRamdisk : public IDriver, IDevice {
public:
u8 Load(CKernel *Kernel);
u8 Unload(void);
// Device interace
u32 GetSize(void);
const u8 *Read(u32 Offset, u32 Length);
void Write(u32 Offset, u32 Length, const u8 *Data);
private:
CKernel *m_Kernel;
};
};
#endif

22
include/Tier1/Drivers/IDevice.h
View File

@ -1,22 +0,0 @@
#ifndef __IDEVICE_H__
#define __IDEVICE_H__
#include "types.h"
namespace cb {
enum IDeviceOperations {
IDO_GET_SIZE = 1,
IDO_READ = 2,
IDO_WRITE = 4
};
class IDevice {
public:
virtual u32 GetSize(void) = 0;
virtual const u8 *Read(u32 Offset, u32 Length) = 0;
virtual void Write(u32 Offset, u32 Length, const u8 *Data) = 0;
IDeviceOperations m_DeviceOperations;
};
};
#endif

36
include/Tier1/Drivers/IDriver.h
View File

@ -1,36 +0,0 @@
#ifndef __IDRIVER_H__
#define __IDRIVER_H__
#include "types.h"
#include "Tier1/CKernel.h"
namespace cb {
class CKernel;
enum EDriverClass {
EDC_NONE,
EDC_FILESYSTEM,
EDC_DEVICE,
BDC_BLOCKDEVICE
};
enum EDriverLoadMethod {
EDLM_ALWAYS = 1,
EDLM_PCIPRESENT = 2,
EDLM_USBPRESENT = 4
};
class IDriver {
public:virtual u8 Load(CKernel *Kernel) = 0;
virtual u8 Unload(void) = 0;
const s8 *m_Name;
const s8 *m_Description;
const s8 *m_Author;
EDriverClass m_Class;
EDriverLoadMethod m_LoadMethod;
bool m_Unloadable;
};
};
#endif

18
include/Tier1/Drivers/Misc/CDriverDummy.h
View File

@ -1,18 +0,0 @@
// A dummy driver that says hello.
#ifndef __CDRIVERDUMMY_H__
#define __CDRIVERDUMMY_H__
#include "Tier1/Drivers/IDriver.h"
namespace cb {
class CDriverDummy : public IDriver {
public:
u8 Load(CKernel *Kernel);
u8 Unload(void);
private:
CKernel *m_Kernel;
};
};
#endif

2
include/Tier1/IScheduler.h
View File

@ -11,7 +11,7 @@ namespace cb {
virtual void AddTask(CTask *Task) = 0;
virtual void NextTask(void) = 0;
virtual CTask *GetCurrentTask(void) = 0;
virtual void DispatchAvailableSemaphore(CSemaphore *Semaphore) = 0;
virtual void SetSemaphoreAvailable(CSemaphore *Semaphore) = 0;
};
};

25
include/Tier1/ITimerSubscriber.h
View File

@ -1,25 +0,0 @@
#ifndef __ITIMERSUBSRCIBER_H__
#define __ITIMERSUBSCRIBER_H__
#include "Tier1/CTimer.h"
namespace cb {
class CTimer;
// An interface used to subscribe to a CTimer
class ITimerSubscriber {
public:
// Gets called after subscribing to a tick with TickDelta
virtual void Tick(u32 TickDelta);
// Returns wether we should be called
virtual bool Enabled(void);
// Basic functions called be derivee
// Unsubscribe from the current subscribed CTimer
void Unsubscribe(void);
void Subscribe(CTimer *Timer, u32 Tick);
};
};
#endif

12
include/Tier1/Util/CVector.h
View File

@ -31,7 +31,7 @@ namespace cb {
const _T *BaseAddress(void) const;
// Size
u32 Size(void);
u32 GetSize(void);
// Search
s32 Find(const _T &Element) const;
@ -80,13 +80,13 @@ namespace cb {
template <class _T> _T &CVector<_T>::Head(void)
{
ASSERT(m_Size > 0);
return m_Members[Size() - 1];
return m_Members[GetSize() - 1];
}
template <class _T> const _T &CVector<_T>::Head(void) const
{
ASSERT(m_Size > 0);
return m_Members[Size() - 1];
return m_Members[GetSize() - 1];
}
template <class _T> _T &CVector<_T>::Tail(void)
@ -111,14 +111,14 @@ namespace cb {
return m_Members;
}
template <class _T> u32 CVector<_T>::Size(void)
template <class _T> u32 CVector<_T>::GetSize(void)
{
return m_Size;
}
template <class _T> s32 CVector<_T>::Find(const _T &Element) const
{
for (u32 i = 0; i < Size(); i++)
for (u32 i = 0; i < GetSize(); i++)
if (m_Members[i] == Element)
return i;
return -1;
@ -126,7 +126,7 @@ namespace cb {
template <class _T> bool CVector<_T>::HasElement(const _T &Element) const
{
for (u32 i = 0; i < Size(); i++)
for (u32 i = 0; i < GetSize(); i++)
if (m_Members[i] == Element)
return true;
return false;

20
src/Tier1/CInterruptsDispatcher.cpp
View File

@ -3,10 +3,10 @@ using namespace cb;
void CInterruptDispatcher::InitializeStatic(void)
{
if (m_InitializedStatic)
if (m_bInitializedStatic)
return;
m_InitializedStatic = true;
m_bInitializedStatic = true;
for (u16 i = 0; i < 256; i++)
m_Dispatchers[i] = 0;
@ -15,18 +15,18 @@ void CInterruptDispatcher::InitializeStatic(void)
CInterruptDispatcher::CInterruptDispatcher(void)
{
if (!m_InitializedStatic)
if (!m_bInitializedStatic)
InitializeStatic();
m_Interrupt = 0;
m_Enabled = false;
m_bEnabled = false;
}
void CInterruptDispatcher::Enable(void)
{
if (m_Enabled)
if (m_bEnabled)
return;
m_Enabled = true;
m_bEnabled = true;
m_Dispatchers[m_Interrupt] = this;
@ -36,10 +36,10 @@ void CInterruptDispatcher::Enable(void)
void CInterruptDispatcher::Disable(void)
{
if (!m_Enabled)
if (!m_bEnabled)
return;
m_Enabled = false;
m_bEnabled = false;
interrupts_delete_isr(m_Interrupt);
}
@ -51,7 +51,7 @@ u8 CInterruptDispatcher::GetInterrupt(void)
bool CInterruptDispatcher::GetEnabled(void)
{
return m_Enabled;
return m_bEnabled;
}
void CInterruptDispatcher::Dispatch(void *Registers)
@ -64,4 +64,4 @@ PPHAX_DO256(CID_SDIS_IMP);
void *CInterruptDispatcher::m_DispatcherFunctions[256];
CInterruptDispatcher *CInterruptDispatcher::m_Dispatchers[256];
bool CInterruptDispatcher::m_InitializedStatic = false;
bool CInterruptDispatcher::m_bInitializedStatic = false;

16
src/Tier1/CKernel.cpp
View File

@ -1,6 +1,4 @@
#include "Tier1/CKernel.h"
#include "Tier1/Drivers/Misc/CDriverDummy.h"
#include "Tier1/Drivers/Device/CDriverRamdisk.h"
#include "Tier1/CPageFaultDispatcher.h"
#include "Tier1/CPageDirectory.h"
#include "Tier1/CTask.h"
@ -26,7 +24,7 @@ extern "C" {
CKernel::CKernel(void)
{
m_Magic = CKERNEL_MAGIC;
m_dwMagic = CKERNEL_MAGIC;
}
CLogger &CKernel::Logger(void)
@ -38,22 +36,14 @@ void CKernel::Start(void)
{
kprintf("[i] Hello from C++ land!\n");
if (m_Magic != CKERNEL_MAGIC)
if (m_dwMagic != CKERNEL_MAGIC)
{
kprintf("[e] Error! My constructor wasn't called properly.\n");
return;
}
m_Logger = new CLogger();
m_DriverManager = new CDriverManager(64, this);
IDriver *Dummy = new CDriverDummy();
m_DriverManager->AddDriver(Dummy);
IDriver *Ramdisk = new CDriverRamdisk();
m_DriverManager->AddDriver(Ramdisk);
m_DriverManager->LoadNew();
CTask *KernelTask = CreateKernelTask();
kprintf("[i] Kernel task has TID %i.\n", KernelTask->GetPID());
CScheduler::AddTask(KernelTask);

4
src/Tier1/CPageDirectory.cpp
View File

@ -27,12 +27,12 @@ CPageDirectory::CPageDirectory(bool Empty)
m_Directory->PhysicalAddress = PhysicalDirectory;
}
m_CreatedEmpty = Empty;
m_bCreatedEmpty = Empty;
}
CPageDirectory::~CPageDirectory(void)
{
if (!m_CreatedEmpty)
if (!m_bCreatedEmpty)
{
for (u16 Table = 0; Table < 1024; Table++)
{

12
src/Tier1/CRoundRobinScheduler.cpp
View File

@ -9,7 +9,7 @@ extern "C" {
void CRoundRobinScheduler::Enable(bool Enabled)
{
m_TaskQueuePosition = 0;
m_iTaskQueuePosition = 0;
}
__attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
@ -22,12 +22,12 @@ __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
// Fetch next task.
CTask *NextTask;
do {
m_TaskQueuePosition++;
m_iTaskQueuePosition++;
if (m_TaskQueuePosition >= m_TaskQueue.GetSize())
if (m_iTaskQueuePosition >= m_TaskQueue.GetSize())
// Something happened - restart the queue
m_TaskQueuePosition = 0;
NextTask = m_TaskQueue[m_TaskQueuePosition];
m_iTaskQueuePosition = 0;
NextTask = m_TaskQueue[m_iTaskQueuePosition];
}
while (NextTask->GetStatus() != ETS_RUNNING);
@ -95,7 +95,7 @@ CTask *CRoundRobinScheduler::GetCurrentTask(void)
return m_CurrentTask;
}
void CRoundRobinScheduler::DispatchAvailableSemaphore(CSemaphore *Semaphore)
void CRoundRobinScheduler::SetSemaphoreAvailable(CSemaphore *Semaphore)
{
u32 Physical = GetCurrentTask()->GetPageDirectory()->
Translate((u32)Semaphore);

2
src/Tier1/CScheduler.cpp
View File

@ -50,5 +50,5 @@ void CScheduler::NextTask(void)
void CScheduler::DispatchAvailableSemaphore(CSemaphore *Semaphore)
{
g_Scheduler.m_CurrentScheduler->DispatchAvailableSemaphore(Semaphore);
g_Scheduler.m_CurrentScheduler->SetSemaphoreAvailable(Semaphore);
}

10
src/Tier1/CTask.cpp
View File

@ -132,7 +132,7 @@ void CTask::Dump(void)
m_ESP, m_EBP, m_EIP);
}
void CTask::CedeTimeSlice(void)
void CTask::Yield(void)
{
CScheduler::NextTask();
}
@ -143,7 +143,7 @@ void CTask::WaitForSemaphore(T_SEMAPHORE *Semaphore)
m_Status = ETS_WAITING_FOR_SEMAPHORE;
m_StatusData = m_Directory->Translate((u32)Semaphore);
CedeTimeSlice();
Yield();
__asm__ volatile ("sti");
}
@ -153,7 +153,7 @@ void CTask::WaitForSemaphore(CSemaphore *Semaphore)
m_Status = ETS_WAITING_FOR_SEMAPHORE;
m_StatusData = m_Directory->Translate((u32)Semaphore);
CedeTimeSlice();
Yield();
__asm__ volatile ("sti");
}
@ -161,7 +161,7 @@ void CTask::Disable(void)
{
__asm__ volatile ("cli");
m_Status = ETS_DISABLED;
CedeTimeSlice();
Yield();
__asm__ volatile ("sti");
}
@ -177,7 +177,7 @@ void CTask::Sleep(u32 Ticks)
__asm__ volatile ("cli");
m_Status = ETS_DISABLED;
CTimer::Create(Ticks, 1, WakeUp, (u32)this);
CedeTimeSlice();
Yield();
__asm__ volatile ("sti");
}

18
src/Tier1/CTimer.cpp
View File

@ -6,8 +6,8 @@ extern "C" {
#include "Tier0/interrupts.h"
}
volatile u32 CTimer::m_NumTicks = 0;
bool CTimer::m_Initialized = false;
volatile u32 CTimer::m_nTicks = 0;
bool CTimer::m_bInitialized = false;
CLinearList<TCallbackInfo> CTimer::m_Callbacks;
void CTimer::Initialize(void)
@ -20,22 +20,22 @@ void CTimer::Initialize(void)
koutb(0x40, High);
interrupts_setup_irq(0x00, (void*)Dispatch);
m_Initialized = true;
m_bInitialized = true;
}
void CTimer::Dispatch(void *Registers)
{
__asm__ volatile("cli");
m_NumTicks++;
m_nTicks++;
if (m_NumTicks > (0xFFFFFFFF - 1000)) // 1000 ticks margin
if (m_nTicks > (0xFFFFFFFF - 1000)) // 1000 ticks margin
Reschedule();
for (u32 i = 0; i < m_Callbacks.GetSize(); i++)
{
TCallbackInfo &Callback = m_Callbacks[i];
if (Callback.Times == -1 || Callback.Times > 0)
{
if (m_NumTicks > Callback.NextCall)
if (m_nTicks > Callback.NextCall)
{
if (Callback.Times != -1)
Callback.Times--;
@ -75,12 +75,12 @@ void CTimer::Reschedule(void)
Callback.NextCall -= Amount;
}
m_NumTicks -= Amount;
m_nTicks -= Amount;
}
void CTimer::Create(u32 Interval, s32 Times, TTimerCallback Callback, u32 Extra)
{
if (!m_Initialized)
if (!m_bInitialized)
Initialize();
TCallbackInfo NewCallback;
@ -88,7 +88,7 @@ void CTimer::Create(u32 Interval, s32 Times, TTimerCallback Callback, u32 Extra)
NewCallback.Interval = Interval;
NewCallback.Times = Times;
NewCallback.Callback = Callback;
NewCallback.NextCall = m_NumTicks + Interval;
NewCallback.NextCall = m_nTicks + Interval;
NewCallback.Extra = Extra;
m_Callbacks.Push(NewCallback);

54
src/Tier1/Drivers/CDriverManager.cpp
View File

@ -1,54 +0,0 @@
#include "Tier1/Drivers/CDriverManager.h"
using namespace cb;
CDriverManager::CDriverManager(u32 MaxDrivers, CKernel *Kernel)
{
m_Kernel = Kernel;
m_aDrivers = new CDriverManagerEntry[MaxDrivers];
m_nMaxDrivers = MaxDrivers;
for (u32 i = 0; i < m_nMaxDrivers; i++)
m_aDrivers[i].Present = false;
}
void CDriverManager::AddDriver(IDriver *Driver)
{
u32 Index = 0;
while (m_aDrivers[Index].Present)
Index++;
m_aDrivers[Index].Present = true;
m_aDrivers[Index].New = true;
m_aDrivers[Index].Loaded = false;
m_aDrivers[Index].Driver = Driver;
}
void CDriverManager::LoadNew(void)
{
for (u32 i = 0; i < m_nMaxDrivers; i++)
{
if (m_aDrivers[i].Present && m_aDrivers[i].New)
{
m_aDrivers[i].New = false;
LoadDriver(i);
}
}
}
void CDriverManager::LoadDriver(u32 Index)
{
IDriver *Driver = m_aDrivers[Index].Driver;
u8 Result = Driver->Load(m_Kernel);
if (Result == 0)
{
m_aDrivers[Index].Loaded = true;
m_Kernel->Logger() << "Loaded driver " << Driver->m_Name << ".";
m_Kernel->Logger().Flush();
}
else
{
m_Kernel->Logger() << "Could not load driver.";
m_Kernel->Logger().Flush();
}
}

37
src/Tier1/Drivers/Device/CDriverRamdisk.cpp
View File

@ -1,37 +0,0 @@
#include "Tier1/Drivers/Device/CDriverRamdisk.h"
using namespace cb;
u8 CDriverRamdisk::Load(CKernel *Kernel)
{
m_Name = "org.q3k.drivers.ramdisk";
m_Description = "Ramdisk Driver";
m_Author = "Sergiusz Bazanski";
m_Class = EDC_DEVICE;
m_LoadMethod = EDLM_ALWAYS;
m_Unloadable = false;
m_DeviceOperations = (IDeviceOperations)(IDO_GET_SIZE | IDO_READ);
m_Kernel = Kernel;
return 0;
}
u8 CDriverRamdisk::Unload(void)
{
return 0;
}
u32 CDriverRamdisk::GetSize(void)
{
return 2;
}
const u8 *CDriverRamdisk::Read(u32 Offset, u32 Length)
{
return (u8*)"lo";
}
void CDriverRamdisk::Write(u32 Offset, u32 Length, const u8 *Data)
{
return;
}

23
src/Tier1/Drivers/Misc/CDriverDummy.cpp
View File

@ -1,23 +0,0 @@
#include "Tier1/Drivers/Misc/CDriverDummy.h"
using namespace cb;
u8 CDriverDummy::Load(CKernel *Kernel)
{
m_Name = "org.q3k.drivers.dummy";
m_Description = "Dummy Driver";
m_Author = "Sergiusz Bazanski";
m_Class = EDC_NONE;
m_LoadMethod = EDLM_ALWAYS;
m_Unloadable = true;
m_Kernel = Kernel;
return 0;
}
u8 CDriverDummy::Unload(void)
{
m_Kernel->Logger() << "Dummy driver unloaded!";
m_Kernel->Logger().Flush();
return 0;
}

133
src/Tier1/Util/CVector.cpp
View File

@ -1,133 +0,0 @@
/*#include "Tier1/Util/CVector.h"
using namespace cb;
extern "C" {
#include "Tier0/heap.h"
#include "Tier0/panic.h"
#include "Tier0/kstdlib.h"
};
template <class _T> CVector<_T>::CVector(u32 StartElements)
{
m_Size = m_MemorySize = StartElements;
if (m_Size > 0)
m_Members = (_T*)kmalloc(m_Size * sizeof(_T));
}
template <class _T> CVector<_T>::~CVector(void)
{
if (m_MemorySize > 0)
kfree(m_Members);
}
template <class _T> _T &CVector<_T>::operator[](u32 Index)
{
ASSERT(Index < m_Size);
return m_Members[Index];
}
template <class _T> const _T &CVector<_T>::operator[](u32 Index) const
{
ASSERT(Index < m_Size);
return m_Members[Index];
}
template <class _T> _T &CVector<_T>::Head(void)
{
ASSERT(m_Size > 0);
return m_Members[Size() - 1];
}
template <class _T> const _T &CVector<_T>::Head(void) const
{
ASSERT(m_Size > 0);
return m_Members[Size() - 1];
}
template <class _T> _T &CVector<_T>::Tail(void)
{
ASSERT(m_Size > 0);
return m_Members[0];
}
template <class _T> const _T &CVector<_T>::Tail(void) const
{
ASSERT(m_Size > 0);
return m_Members[0];
}
template <class _T> _T *CVector<_T>::BaseAddress(void)
{
return m_Members;
}
template <class _T> const _T *CVector<_T>::BaseAddress(void) const
{
return m_Members;
}
template <class _T> u32 CVector<_T>::Size(void)
{
return m_Size;
}
template <class _T> s32 CVector<_T>::Find(const _T &Element) const
{
for (u32 i = 0; i < Size(); i++)
if (m_Members[i] == Element)
return i;
return -1;
}
template <class _T> bool CVector<_T>::HasElement(const _T &Element) const
{
for (u32 i = 0; i < Size(); i++)
if (m_Members[i] == Element)
return true;
return false;
}
template <class _T> _T &CVector<_T>::Pop(void)
{
ASSERT(m_Size > 0);
}
template <class _T> void CVector<_T>::MoarMemoryPlox(void)
{
u32 NewSize = m_MemorySize * 2;
_T *NewData = (_T*)kmalloc(NewSize * sizeof(_T));
// Copy the data over
kmemcpy((void*)NewData, (void*)m_Members, m_MemorySize * sizeof(_T));
kfree(m_Members);
m_Members = NewData;
m_MemorySize = NewSize;
}
template <class _T> void CVector<_T>::Push(const _T &Element)
{
if (m_Size + 1 > m_MemorySize)
MoarMemoryPlox();
#ifdef CVECTOR_MEMCPY_ELEMENTS
kmemcpy((void*)(m_Members + m_Size), (void*)&Element, sizeof(_T));
#else
m_Members[m_Size] = Element;
#endif
m_Size++;
}
template <class _T> void CVector<_T>::PushNew(void)
{
if (m_Size + 1 > m_MemorySize)
MoarMemoryPlox();
(m_Members + m_Size) = new _T();
m_Size++;
}*/