HeeroYui/edn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

debut de déplacement du vecteur

Browse Source
This commit is contained in:
Edouard Dupin
2011-07-29 17:07:46 +02:00
parent 0fe575e432
commit e3e868f351
5 changed files with 24 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
Sources/tools/EdnTemplate/EdnTemplateTest.cpp
View File

@@ -1,29 +0,0 @@
#include "tools_debug.h"
#include "tools_globals.h"
#include "VectorType.h"
void TestTemplate(void)
{
EDN_WARNING("Start Template Test ...");
Edn::VectorType<int32_t> plop;
Edn::VectorType<int8_t> plop2;
plop.PushBack(15365);
plop.PushBack(1);
plop.PushBack(2);
plop.PushBack(3);
plop.PushBack(4);
EDN_INFO("data is : " << plop[0]);
EDN_INFO("data is : " << plop[1]);
EDN_INFO("data is : " << plop[2]);
EDN_INFO("data is : " << plop[3]);
plop2.PushBack(65);
EDN_INFO("data is : " << plop2[0]);
}

186
Sources/tools/EdnTemplate/EdnTree.h
View File

@@ -1,186 +0,0 @@
/**
*******************************************************************************
* @file EdnTree.h
* @brief Editeur De N'ours : Basic tree in a vector For none expensive tree (template)
* @author Edouard DUPIN
* @date 04/04/2011
* @par Project
* Edn
*
* @par Copyright
* Copyright 2010 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
* You can not earn money with this Software (if the source extract from Edn
* represent less than 50% of original Sources)
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#ifndef __EDN_TREE_H__
#define __EDN_TREE_H__
#undef __class__
#define __class__ "EdnTreeElement"
template < class T > class EdnTreeElement
{
public:
EdnTreeElement(int32_t parent, int32_t id, T &maNouvelleClass) : elementPtr(NULL), m_parent(parent), m_id(id)
{
elementPtr = new T(maNouvelleClass);
};
~EdnTreeElement(void)
{
delete(elementPtr);
};
EdnTreeElement(const EdnTreeElement &mustCopy ) : elementPtr(NULL), m_parent(mustCopy.m_parent), m_id(mustCopy.m_id)
{
elementPtr = new T(*mustCopy.elementPtr);
}
int32_t GetParrent(void) { return m_parent;};
int32_t GetId(void) { return m_id;};
T* GetPtr() const
{
return elementPtr;
};
private:
T* elementPtr; // pointer on the curent element
int32_t m_parent;
int32_t m_id;
};
#undef __class__
#define __class__ "EdnTree"
#define ROOT_NODE_ID (-1)
template < class T > class EdnTree
{
public:
// constructeur et destructeur
EdnTree(void)
{
m_LastId = 0;
};
~EdnTree(void)
{
};
// Common function ...
int32_t GetNumberNode(void)
{
return m_listElement.size();
};
int32_t GetDepth(void)
{
// TODO : ...
return 0;
};
//!< add an element in the tree
int32_t Add(T &maNouvelleClass, int32_t parent=-1)
{
if (true == CheckPresenceParrent(parent)) {
// create the local element
EdnTreeElement<T> nouvelElement(parent, m_LastId, maNouvelleClass);
// add it in the list
m_listElement.push_back(nouvelElement);
// increment the ID of the element
m_LastId++;
// Add is Ok, in theory ...
return m_LastId-1;
}
return -2;
};
bool Remove(int32_t id)
{
return false;
};
bool Clear(void)
{
return false;
};
T* Get(int32_t id)
{
// try to find ID
int32_t realID = FindElementWithId(id);
// when we find it, check it
if (0 > realID || realID >= m_LastId) {
return NULL;
}
// Return the element :
return m_listElement[realID].GetPtr();
};
std::vector<int32_t> GetListSubNode( int32_t parentId = ROOT_NODE_ID)
{
std::vector<int32_t> res;
int32_t i;
for (i=0; i<(int32_t)m_listElement.size(); i++) {
if (m_listElement[i].GetParrent() == parentId) {
// Add the element ID in the list ...
res.push_back(m_listElement[i].GetId());
}
}
return res;
};
std::vector<int32_t> Root(void)
{
return GetListSubNode(ROOT_NODE_ID);
};
private:
int32_t m_LastId;
std::vector< EdnTreeElement<T> > m_listElement; //!< list of element...
bool CheckPresence(int32_t id)
{
int32_t i;
for (i=0; i<(int32_t)m_listElement.size(); i++) {
if (m_listElement[i].GetId() == id) {
return true;
}
}
return false;
};
bool CheckPresenceParrent(int32_t parrentId)
{
if (ROOT_NODE_ID == parrentId) {
return true;
}
return CheckPresence(parrentId);
};
int32_t FindElementWithId(int32_t id)
{
int32_t i;
for (i=0; i<(int32_t)m_listElement.size(); i++) {
if (m_listElement[i].GetId() == id) {
return i;
}
}
return ROOT_NODE_ID;
};
};
#undef __class__
#define __class__ NULL
#endif

497
Sources/tools/EdnTemplate/EdnVector.h
View File

@@ -1,497 +0,0 @@
/**
*******************************************************************************
* @file EdnEdnVector.h
* @brief Editeur De N'ours : Basic EdnVector (template)
* @author Edouard DUPIN
* @date 07/04/2011
* @par Project
* Edn
*
* @par Copyright
* Copyright 2010 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
* You can not earn money with this Software (if the source extract from Edn
* represent less than 50% of original Sources)
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#ifndef __EDN_EdnVector_H__
#define __EDN_EdnVector_H__
#undef __class__
#define __class__ "EdnEdnVector"
/**
* @brief EdnVector classes ...
*
* @tparam[in] T The type of objects to store.
* @tparam[in] INC Incrementation mode (0 : Exponential to 200 and increment by stemp of 200)
*
* @todo : Need to add : popBack / Assign / Insert / Erase / Swap / Clear
*
* m_data
* ---------- |-----------------------|
* | 0 |-------->| Class Data |
* |--------| |-----------------------|
* | 1 |----|
* |--------| |
* | 2 |====|==============| |-----------------------|
* |--------| | --->| Class Data |
* m_count | 3 |-| | |-----------------------|
* |--------| | |
* | x | | | |-----------------------|
* |--------| | -------->| Class Data |
* | x | | |-----------------------|
* |--------| |
* | x | |
* |--------| | |-----------------------|
* | x | --------------------->| Class Data |
* |--------| |-----------------------|
* | x |
* |--------|
* | x |
* |--------|
* m_size | x |
* ----------
*
*/
template<class T, int32_t INC=0> class EdnVector:
{
public:
class Iterator:
{
// Private data :
private:
int32_t m_current; // curent Id on the vector
EdnVector<T> * m_EdnVector; // Pointer on the curent element of the vector
public:
/**
* @brief Basic itarator constructor with no link with an EdnVector
*/
Iterator():
m_current(-1),
m_EdnVector(NULL)
{
// nothing to do ...
}
/**
* @brief Recopy constructor on a specific EdnVector.
* @param[in] otherIterator The Iterator that might be copy
*/
Iterator(const Iterator & otherIterator):
m_current(otherIterator.m_current),
m_EdnVector(otherIterator.m_EdnVector)
{
// nothing to do ...
}
/**
* @brief Asignation operator.
* @param[in] otherIterator The Iterator that might be copy
* @return reference on the curent Iterator
*/
Iterator& operator=(const Iterator & otherIterator)
{
m_current = otherIterator.m_current;
m_EdnVector = otherIterator.m_EdnVector;
return *this;
}
/**
* @brief Basic destructor
*/
~Iterator()
{
m_current = -1;
m_EdnVector = NULL;
}
/**
* @brief basic boolean cast
* @return true if the element is present in the EdnVector size
*/
operator bool ()
{
if( 0 <= m_current
&& m_current < m_EdnVector->Size() )
{
return true;
} else {
return false;
}
}
/**
* @brief Incremental operator
* @return Reference on the current iterator incremented
*/
Iterator& operator++ ()
{
if( NULL != m_EdnVector
&& m_current < m_EdnVector->Size() )
{
m_current++;
}
return *this;
}
/**
* @brief Decremental operator
* @return Reference on the current iterator decremented
*/
Iterator& operator-- ()
{
if (m_current >= 0) {
m_current--;
}
return *this;
}
/**
* @brief Incremental operator
* @return Reference on a new iterator and increment the other one
*/
Iterator operator++ (int32_t)
{
Iterator it(*this);
++(*this);
return it;
}
/**
* @brief Decremental operator
* @return Reference on a new iterator and decrement the other one
*
*/
Iterator operator-- (int32_t)
{
Iterator it(*this);
--(*this);
return it;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
T * operator-> () const
{
EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVector->Size());
return &m_EdnVector->Get(m_current);
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
T & operator* () const
{
EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVector->Size());
return m_EdnVector->Get(m_current);
}
private:
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
Iterator(EdnVector<T> * EdnVector, int pos):
m_current(pos),
m_EdnVector(EdnVector)
{
// nothing to do ...
}
friend class EdnVector;
};
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
EdnVector(int count = 0):
m_data(NULL),
m_count(0),
m_size(0)
{
Resize(count);
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
EdnVector(const EdnVector<T> & EdnVector):
m_size(EdnVector.m_size),
m_count(EdnVector.m_count),
m_data(NULL)
{
int32_t i;
EDN_MALLOC_CAST(m_data, m_size, T, reinterpret_cast<T*>);
for(i=0; i<m_count; i++) {
new (&m_data[i]) T(EdnVector[i]);
}
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
~EdnVector()
{
Destroy();
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
EdnVector& operator=(const EdnVector<T> & EdnVector)
{
int32_t i;
this->~EdnVector();
m_size = EdnVector.m_size;
m_count = EdnVector.m_count;
EDN_MALLOC_CAST(m_data, m_size, T, reinterpret_cast<T*>);
for(i=0; i<m_count; i++) {
new (&m_data[i]) T(EdnVector[i]);
}
return *this;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t Size()
{
return m_count;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
T& Get(int32_t pos)
{
return m_data[pos];
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
T& operator[] (int32_t pos)
{
return Get(pos);
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
const T& operator[] (int32_t pos) const
{
return m_data[pos];
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int IndexOf(const T * item) const
{
int32_t res = item - m_data;
if( 0 > res
|| res >= Size())
{
return -1
} else {
return res;
}
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void PushBack(const T& item)
{
int32_t idx = Size();
Resize(idx+1);
Get(idx) = item;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
Iterator Get(int pos)
{
return Iterator(this, pos);
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
Iterator Begin()
{
return Get(0);
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
Iterator End()
{
return Get( Size()-1 );
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void Resize(int32_t count)
{
int32_t i;
// Reallocate memory
if (count > m_size) {
ChangeAllocation(count);
}
// Remove deprecated element
for(i=count; i<m_count; i++) {
m_data[i].~T();
}
// Create nex item
for(i=m_count;i<count;i++) {
new (&m_data[i]) T();
}
m_count = count;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void ChangeAllocation(int count)
{
if (count > m_size) {
// generate new size
while(count > m_size) {
if (INC) {
m_size = (m_size + INC)
} else if (m_size==0) {
m_size = 1;
} else {
m_size = m_size * 2;
}
}
// Allocate the curent element
T * data = NULL;
EDN_MALLOC_CAST(data, m_size, T, reinterpret_cast<T*>);
for(int i=0; i<m_count; i++) {
new (&data[i]) T(m_data[i]);
}
Destroy();
m_data = data;
}
}
private:
T * m_data; //!< pointer on the current Data
int32_t m_count; //!< number of element
int32_t m_size; //!< current allocated size
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void Destroy()
{
for(int i=0; i<m_count; i++) {
m_data[i].~T();
}
if (m_data) {
EDN_FREE(m_data);
}
}
};
#undef __class__
#define __class__ NULL