manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

*** empty log message ***

This commit is contained in:
ganovelli 2004-03-30 22:48:54 +00:00
parent 9c4727960d
commit 733e581689
3 changed files with 569 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
vcg/container_allocation_table.h Normal file
View File

@ -0,0 +1,317 @@
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCGLIB_CAT__
#define __VCGLIB_CAT__
#include <vector>
#include <list>
#include <algorithm>
#include <assert.h>
#include <vcg/entries_allocation_table.h>
namespace vcg {
// CATBase: abstract base class for all the allocation tables
template <class STL_CONT>
class CATBase{
public:
typedef STL_CONT::value_type VALUE_TYPE;
virtual void Resort(VALUE_TYPE*,VALUE_TYPE*) =0;
virtual void Remove(const STL_CONT&) = 0;
virtual void AddDataElem(VALUE_TYPE*,int)=0;
virtual void Reserve(STL_CONT::value_type * pt,const int & rs)=0;
virtual void Resize(STL_CONT::value_type * pt,const int & rs)=0;
public:
// ID serve as a type trait.
static int & Id(){
static int id=0;
return id;
}
};
// CATEntry: first derivation templated on the type of entry
// It implements all the methods to trace and access TVector element
template <class STL_CONT, class ENTRY_TYPE>
class CATEntry: public CATBase<STL_CONT>{
public:
typedef STL_CONT::value_type VALUE_TYPE;
CATEntry(){if(Id()==0){
Id() = CATBase<STL_CONT>::Id()+1;
CATBase<STL_CONT>::Id() = Id();
}
}
static unsigned int Ord(VALUE_TYPE *);
virtual void Remove( const STL_CONT & c); // remove the container c
static void Remove( VALUE_TYPE * v); // remove the container that contains v
virtual void Resort( VALUE_TYPE* old_start, // resort the allocation table
VALUE_TYPE* new_start); // after a container was moved
protected:
static std::list<ENTRY_TYPE >& AT(){ // tallocation table
static std::list<ENTRY_TYPE > allocation_table;
return allocation_table;
}
static bool & UTD(){
static bool upToDate; // true if Lower() and Upper()
return upToDate; // are up to date
}
static VALUE_TYPE *& Lower() {
static VALUE_TYPE * lower; // pointer to the first element
return lower; // of the last container accessed
}
static VALUE_TYPE *& Upper() {
static VALUE_TYPE * upper; // pointer to the first element
return upper; // if the container next to the last accessed
}
static std::list<ENTRY_TYPE>::iterator & Curr(){ // container that was last accessed
static std::list<ENTRY_TYPE>::iterator currEntry;
return currEntry;
}
static bool IsTheSameAsLast(VALUE_TYPE *pt); // true if pt is in the container
// that was accessed last
static void Update(VALUE_TYPE*); // set Upper() e Lower()
static std::list<ENTRY_TYPE>::iterator FindBase(const VALUE_TYPE * pt);
// find the container that contains pt (naive)
public:
static int & Id(){ // unique identifier of the istance
static int id=0; // (used as type trait)
return id;
}
};
// --------------------------- CATEntry: implementation --------------------
template <class STL_CONT, class ENTRY_TYPE>
unsigned int CATEntry<STL_CONT,ENTRY_TYPE>::
Ord(VALUE_TYPE * pt)
{
Update(pt);
return (pt-Lower());
}
template <class STL_CONT, class ENTRY_TYPE>
std::list<ENTRY_TYPE>::iterator CATEntry<STL_CONT,ENTRY_TYPE>::
FindBase(const VALUE_TYPE * pt)
{
std::list<ENTRY_TYPE>::iterator
ite = AT().begin(),curr_base;
std::list<ENTRY_TYPE> tmp = AT();
for(;ite != AT().end();ite++)
if( pt < (*ite).Start())
return curr_base;
else
curr_base = ite;
return curr_base;
}
template <class STL_CONT, class ENTRY_TYPE>
bool CATEntry< STL_CONT, ENTRY_TYPE>::
IsTheSameAsLast(VALUE_TYPE * pt)
{
return ( UTD() && ( !(Lower()> pt)) && (pt < Upper()) );
}
template <class STL_CONT, class ENTRY_TYPE>
void CATEntry< STL_CONT, ENTRY_TYPE>::
Update(VALUE_TYPE * pt)
{
if(!IsTheSameAsLast(pt)){
std::list<ENTRY_TYPE>::iterator lower_ite;
lower_ite = FindBase(pt);
assert( lower_ite!=AT().end());
Lower() = (*lower_ite).Start();
if( (*lower_ite).Start() == AT().back().Start())
Upper() = (VALUE_TYPE *) 0xffffffff;
else
{
lower_ite++;
Upper() = (*lower_ite).Start();
}
Curr() = lower_ite;
UTD() = true;
}
}
template <class STL_CONT, class ENTRY_TYPE>
void CATEntry< STL_CONT, ENTRY_TYPE>::
Resort(VALUE_TYPE* old_start,VALUE_TYPE* new_start)
{
AT().sort();
UTD() = false;
}
template <class STL_CONT, class ENTRY_TYPE>
void CATEntry<STL_CONT, ENTRY_TYPE>::
Remove( const STL_CONT & c )
{
std::list<ENTRY_TYPE>::iterator ite;
for(ite = AT().begin(); (*ite).C() != &c;++ite)
AT().erase(ite);
UTD() = false;
}
template <class STL_CONT, class ENTRY_TYPE>
void CATEntry<STL_CONT, ENTRY_TYPE>::
Remove(VALUE_TYPE * pt)
{
std::list<ENTRY_TYPE>::iterator lower_ite;
lower_ite = FindBase(pt);
AT().erase(lower_ite);
UTD() = false;
}
// CAT: derivation of CATEntry for the case where the temporary data is unique for each type.
// VERY IMPORTANT: there cannot be two vector of value with the same type of temporary datya
// This class is used to implement optional core data (NormalOpt, CoordOpt etc...)
// For generic user-defined data see CATMulti
template <class STL_CONT,class ATTR_TYPE>
class CAT:public CATEntry<STL_CONT, EntryCAT<STL_CONT,ATTR_TYPE> >{
public:
typedef typename EntryCAT<STL_CONT,ATTR_TYPE> EntryType;
static ATTR_TYPE & Get(STL_CONT::value_type * pt);
static std::vector<ATTR_TYPE> & Data(STL_CONT::value_type * pt);
static void Insert( STL_CONT & c);
virtual void Reserve(STL_CONT::value_type * pt,const int & rs);
virtual void Resize(STL_CONT::value_type * pt,const int & rs);
virtual void AddDataElem(STL_CONT::value_type * pt,int n);// add n element to the auxiliary data
};
//---------------------- CAT: implementation---------------------------------------------------
template <class STL_CONT, class ATTR_TYPE>
void CAT<STL_CONT,ATTR_TYPE>::
AddDataElem(STL_CONT::value_type * pt,int n)
{
Update(pt);
for(int i = 0 ; i < n; ++i)
Curr()->push_back();
}
template <class STL_CONT, class ATTR_TYPE>
ATTR_TYPE & CAT<STL_CONT,ATTR_TYPE>::
Get(STL_CONT::value_type * pt)
{
int ord = Ord(pt);
return Curr()->Data()[ord];
}
template <class STL_CONT, class ATTR_TYPE>
std::vector<ATTR_TYPE> & CAT<STL_CONT,ATTR_TYPE>::
Data(STL_CONT::value_type * pt)
{
Update(pt);
return Curr()->Data();
}
template <class STL_CONT, class ATTR_TYPE>
void CAT<STL_CONT, ATTR_TYPE>::
Insert( STL_CONT & c )
{
EntryType entry(c);
std::list<EntryType>::iterator lower_ite,upper_ite;
upper_ite = std::lower_bound(AT().begin(), AT().end(), entry);
lower_ite = AT().insert(upper_ite,entry);
lower_ite->Data().reserve(c.capacity());
lower_ite->Data().resize(c.size());
UTD() = false;
}
template <class STL_CONT, class ATTR_TYPE>
void CAT<STL_CONT, ATTR_TYPE>::
Reserve(STL_CONT::value_type * pt,const int & rs)
{
Update(pt);
Curr()->Data().reserve(rs);
}
template <class STL_CONT, class ATTR_TYPE>
void CAT<STL_CONT, ATTR_TYPE>::
Resize(STL_CONT::value_type * pt,const int & rs)
{
Update(pt);
Curr()->Data().resize(rs);
}
template <class STL_CONT,class ENTRY_TYPE>
class CATMulti:public CATEntry<STL_CONT, ENTRY_TYPE >{
public:
typedef typename ENTRY_TYPE EntryType;
static void Insert( STL_CONT & c);
static ENTRY_TYPE & GetEntry(STL_CONT::value_type *);
virtual void Reserve(const int & rs){};
virtual void Resize(const int & rs){};
};
// --------------------------- CATMulti: implementation ------------------
template <class STL_CONT,class ENTRY_TYPE>
void CATMulti<STL_CONT, ENTRY_TYPE>::
Insert( STL_CONT & c )
{
ENTRY_TYPE entry(c);
std::list<EntryType>::iterator lower_ite,upper_ite;
upper_ite = std::lower_bound(AT().begin(), AT().end(), entry);
lower_ite = AT().insert(upper_ite,entry);
UTD() = false;
}
template <class STL_CONT,class ENTRY_TYPE>
ENTRY_TYPE & CATMulti<STL_CONT, ENTRY_TYPE>::
GetEntry(STL_CONT::value_type*pt){
Update(pt);
return *Curr();
}
};//end namespace vcg
#endif

100
vcg/entries_allocation_table.h Normal file
View File

@ -0,0 +1,100 @@
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCGLIB_ENTRIES__
#define __VCGLIB_ENTRIES__
namespace vcg {
// EntryCATBase: base class for the entry of the allocation table
// templated over the container type
template <class STL_CONT>
struct EntryCATBase{
EntryCATBase(STL_CONT & _c):c(_c){};
STL_CONT::value_type * Start() const;
const STL_CONT * C();
virtual void push_back(){}
const bool operator < (const EntryCATBase<STL_CONT> & other) const;
private:
STL_CONT & c;
};
//EntryCAT: entry for the case of optional core types (matches with CAT)
template <class STL_CONT,class ATTR_TYPE >
struct EntryCAT: public EntryCATBase<STL_CONT>{
typedef ATTR_TYPE attr_type;
EntryCAT(STL_CONT & _c) : EntryCATBase<STL_CONT>(_c){};
std::vector<ATTR_TYPE> & Data(){return data;}
void push_back(){ data.push_back(ATTR_TYPE());}
private:
std::vector<ATTR_TYPE> data;
};
//----------------------EntryCAT: implementation ----------------------------------------
template <class STL_CONT>
const bool EntryCATBase<STL_CONT>:: operator < (const EntryCATBase<STL_CONT> & other) const{
return (Start() < other.Start());
}
template <class STL_CONT>
STL_CONT::value_type * EntryCATBase<STL_CONT>::Start()const {
return &(*(c.begin()));
}
template <class STL_CONT>
const STL_CONT * EntryCATBase<STL_CONT>::C(){
return &c;
}
// EntryCATMulti: entry type for generic data (matches with CATMulti)
template <class STL_CONT>
struct EntryCATMulti: public EntryCATBase<STL_CONT>{
EntryCATMulti(STL_CONT & _c) : EntryCATBase<STL_CONT>(_c){};
std::list< void * > & Data(){return data;}
void push_back(){}
private:
std::list< void * > data;
};
template <class STL_CONT, class ATTR_TYPE>
class TempData{
public:
TempData(std::vector<ATTR_TYPE> *d):item(d){};
typedef typename ATTR_TYPE attr_type;
std::vector<ATTR_TYPE> * Item(){return item;};
std::vector<ATTR_TYPE> * item;
ATTR_TYPE & operator [](STL_CONT::value_type * v)
{
int pos = CATMulti<STL_CONT, EntryCATMulti<STL_CONT> >::Ord(v);
return (*item)[pos];
}
};
}; // end namespace vcg
#endif

152
vcg/traced_vector.h Normal file
View File

@ -0,0 +1,152 @@
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCGLIB_TRACED_VECTOR__
#define __VCGLIB_TRACED_VECTOR__
#include <vcg/container_allocation_table.h>
#include <assert.h>
namespace vcg {
template <class VALUE_TYPE>
class TVector: public std::vector<VALUE_TYPE>{
typedef TVector<VALUE_TYPE> THIS_TYPE;
public:
TVector():std::vector<VALUE_TYPE>(){reserve(1);}
~TVector();
std::list < CATBase<THIS_TYPE>* > attributes;
// override di tutte le funzioni che possono spostare
// l'allocazione in memoria del container
void push_back(const VALUE_TYPE & v);
void pop_back();
void resize(const unsigned int & size);
void reserve(const unsigned int & size);
template <class ATTR_TYPE>
void EnableAttribute(){
CAT<THIS_TYPE,ATTR_TYPE> * cat = new CAT<THIS_TYPE,ATTR_TYPE>();
cat->Insert(*this);
attributes.push_back(cat);
}
template <class ATTR_TYPE>
void DisableAttribute(){
std::list < CATBase<THIS_TYPE> * >::iterator ia;
for(ia = attributes.begin(); ia != attributes.end(); ++ia)
if((*ia)->Id() == CAT<THIS_TYPE,ATTR_TYPE>::Id())
{
(*ia)->Remove(*this);
delete (*ia);
attributes.erase(ia);
break;
}
}
template <class ATTR_TYPE>
TempData<THIS_TYPE,ATTR_TYPE> NewTempData(){
//CAT<THIS_TYPE,EntryCATMulti>::Insert(*this)
CATMulti<THIS_TYPE,EntryCATMulti<THIS_TYPE> >::EntryType
entry = CATMulti<THIS_TYPE,EntryCATMulti<THIS_TYPE> >::GetEntry(&*begin());
entry.Data().push_back(new std::vector<ATTR_TYPE>);
((std::vector<ATTR_TYPE>*)entry.Data().back())->reserve(capacity());
((std::vector<ATTR_TYPE>*)entry.Data().back())->resize(size());
return TempData<THIS_TYPE,ATTR_TYPE>((std::vector<ATTR_TYPE>*) entry.Data().back());
}
template <class ATTR_TYPE>
void DeleteTempData(TempData<THIS_TYPE,ATTR_TYPE> & td){
//CAT<THIS_TYPE,EntryCATMulti>::Insert(*this)
CATMulti<THIS_TYPE,EntryCATMulti<THIS_TYPE> >::EntryType
entry = CATMulti<THIS_TYPE,EntryCATMulti<THIS_TYPE> >::GetEntry(&*begin());
entry.Data().remove(td.Item());
delete td.Item();
}
private:
VALUE_TYPE * old_start;
void Update();
};
template <class VALUE_TYPE>
void TVector<VALUE_TYPE>::push_back(const VALUE_TYPE & v){
std::vector<VALUE_TYPE>::push_back(v);
std::list < CATBase<THIS_TYPE> * >::iterator ia;
for(ia = attributes.begin(); ia != attributes.end(); ++ia)
(*ia)->AddDataElem(&(*(this->begin())),1);
Update();
}
template <class VALUE_TYPE>
void TVector<VALUE_TYPE>::pop_back(){
std::vector<VALUE_TYPE>::pop_back();
Update();
}
template <class VALUE_TYPE>
void TVector<VALUE_TYPE>::resize(const unsigned int & size){
std::vector<VALUE_TYPE>::resize(size);
std::list < CATBase<THIS_TYPE> * >::iterator ia;
for(ia = attributes.begin(); ia != attributes.end(); ++ia)
(*ia)->
Update();
}
template <class VALUE_TYPE>
void TVector<VALUE_TYPE>::reserve(const unsigned int & size){
std::vector<VALUE_TYPE>::reserve(size);
Update();
}
template <class VALUE_TYPE>
void TVector<VALUE_TYPE>::
Update(){
std::list < CATBase<THIS_TYPE> * >::iterator ia;
if(&(*begin()) != old_start)
for(ia = attributes.begin(); ia != attributes.end(); ++ia)
(*ia)->Resort(old_start,&(*begin()));
old_start = &(*begin());
}
template <class VALUE_TYPE>
TVector<VALUE_TYPE>::~TVector(){
std::list < CATBase<THIS_TYPE> * >::iterator ia;
for(ia = attributes.begin(); ia != attributes.end(); ++ia)
{
(*ia)->Remove(*this);
delete *ia;
}
}
}; // end namespace
#endif