Page MenuHomec4science
Files F88458209

refobj.h
No OneTemporary
Actions

File Metadata

Created
Fri, Oct 18, 21:47

refobj.h
View Options

/*s***************************************************************************
*
* Copyright (c), Ilya Valuev 2006 All Rights Reserved.
*
* Author : Ilya Valuev, MIPT, Moscow, Russia
*
* Project : ivutils
*
*****************************************************************************/
/*s****************************************************************************
* $Log: refobj.h,v $
* Revision 1.2 2011/06/11 16:53:55 valuev
* sync with LAMMPS
*
* Revision 1.1 2011/06/10 17:15:07 morozov
* First Windows project with the correct directory structure
*
* Revision 1.15 2010/10/07 11:20:31 valuev
* preliminary program restart
*
* Revision 1.14 2009/07/24 05:08:46 valuev
* Sync with FDTD, added molecule setup
*
* Revision 1.33 2009/05/19 21:50:17 valuev
* Added TestRay for plane
*
* Revision 1.32 2009/03/23 22:00:48 lesha
* const mngptr &operator=(const mngarg<T> &arg) is added
*
* Revision 1.31 2009/01/30 13:54:05 valuev
* restructured as a library
*
* Revision 1.30 2009/01/21 09:28:15 lesha
* refvector::clear is added
*
* Revision 1.29 2009/01/15 07:31:07 lesha
* *** empty log message ***
*
* Revision 1.28 2009/01/14 10:02:36 lesha
* operator [] is added to mngptr
*
* Revision 1.27 2008/04/29 01:23:59 lesha
* nothing important
*
* Revision 1.26 2008/02/28 08:57:27 lesha
* shptr::free() is made public
*
* Revision 1.25 2008/02/27 13:37:23 lesha
* shptr is added
*
* Revision 1.24 2008/01/22 10:14:05 lesha
* mngarg is added
*
* Revision 1.23 2007/08/08 10:55:37 lesha
* constructor in refvector is correted
*
* Revision 1.22 2007/07/10 19:52:44 lesha
* make gcc compilable
*
* Revision 1.21 2007/07/06 12:23:37 valuev
* made compilable with icc 9
*
* Revision 1.20 2007/06/22 09:42:25 valuev
* *** empty log message ***
*
* Revision 1.19 2007/06/17 00:51:44 lesha
* refobj, refcounter :: reset is modified for ptr==this->ptr case
*
* Revision 1.18 2007/06/05 16:30:53 lesha
* make gcc compilable
*
* Revision 1.17 2007/06/05 11:37:53 lesha
* make gcc compilable
*
* Revision 1.16 2007/06/05 11:07:04 lesha
* make gcc compilable
*
* Revision 1.15 2007/06/04 14:03:55 lesha
* *** empty log message ***
*
* Revision 1.14 2007/05/31 18:00:42 lesha
* *** empty log message ***
*
* Revision 1.13 2007/05/31 16:57:30 lesha
* ref_sequence is added
*
* Revision 1.12 2007/05/31 01:25:01 lesha
* new version of mng_ptr, pencil etc
*
* Revision 1.11 2007/02/20 10:26:11 valuev
* added newlines at end of file
*
* Revision 1.10 2007/02/16 10:16:51 valuev
* allowed array mngptr
*
* Revision 1.4 2007/02/16 09:40:32 valuev
* Added Nudged Elastic Band saddle point search
*
* Revision 1.3 2006/12/20 14:29:33 valuev
* Updated workflow, sync with FDTD
*
* Revision 1.9 2006/12/14 08:42:36 valuev
* reformulated detector
* projectors, corrected open file limit control, tested Fourier sceleton
*
* Revision 1.8 2006/11/29 18:05:05 valuev
* made the code compilable with g++
*
* Revision 1.7 2006/11/29 17:17:01 valuev
* added using base_t::member for ANSI-compatibility
*
* Revision 1.6 2006/11/29 17:11:59 valuev
* added includes
*
* Revision 1.5 2006/11/28 09:16:59 valuev
* Fixed vectors storing managed pointers
*
* Revision 1.4 2006/11/24 20:17:31 valuev
* Added CVS headers
*
*******************************************************************************/
#ifndef _REFOBJ_H
#define _REFOBJ_H
# include <utility>
# include <vector>
# include <map>
using namespace std;
template<class T>
class mngarg: public pair<T *, int>{
public:
typedef pair<T *, int> base_t;
using base_t::second;
using base_t::first;
mngarg(T *ptr, int managed=0): pair<T*,int>(ptr,managed){}
template<class A>
mngarg(const mngarg<A> &arg): pair<T*,int>(arg.first,arg.second){}
};
template<class T>
mngarg<T> make_mngarg(T *ptr, int managed=1){
return mngarg<T>(ptr,managed);
}
/// managed pointer
/// managed==0 do not delete
/// managed==1 delete
/// (NOT IMPLEMENTED) managed==2 copy and delete, requires copy constructor
/// flag 0x8 -- delete as array
template<class T>
class mngptr: public pair<T *, int>{
public:
typedef pair<T *, int> base_t;
typedef T *pointer;
using base_t::second;
using base_t::first;
mngptr(T* ptr=NULL, int managed=0): pair<T*,int>(ptr,managed){
//if(managed==2)ptr= new T(*ptr);
}
mngptr(const mngarg<T> &arg): pair<T*,int>(arg.first,arg.second){}
const mngptr &operator=(const mngarg<T> &arg){
reset(arg.first,arg.second);
return *this;
}
void reset(T* ptr=NULL, int managed=0){
if(second && first && first!=ptr){
if(second&0x8)delete [] first;
else delete first;
}
first=ptr;
second=managed;
}
void reset(const mngarg<T> &arg){
reset(arg.first,arg.second);
}
T* ptr() const {
return first;
}
T* operator->() const {
return first;
}
T& operator*() const{
return *first;
}
T& operator[] (int i) const{
return *(first+i);
}
int managed() const {
return second;
}
~mngptr(){
reset();
}
};
# if 0
template <template<class _type> class cont_tt, class T>
class refcontainer: public cont_tt< T * >{
protected:
int man;
public:
typedef cont_tt< T * > base_t;
typedef typename base_t::iterator iterator;
typedef typename base_t::const_iterator const_iterator;
refcontainer(int smanaged=0):man(smanaged){}
refcontainer(size_t n, int smanaged=0):base_t(n),man(smanaged){}
void set_managed(int sman){
man=sman;
}
~refcontainer(){
if(man){
size_t i, n=base_t::size();
for(i=0;i<n;i++)
if((*this)[i]) delete (*this)[i];
}
}
};
# endif
template < class T >
class refvector: public std::vector< T * >{
protected:
int man;
public:
typedef vector<T*> base_t;
typedef typename base_t::iterator iterator;
typedef typename base_t::const_iterator const_iterator;
refvector(int smanaged=0):man(smanaged){}
// refvector(size_t n, int smanaged=0):base_t(n),man(smanaged){} // ambigious constructors
refvector(size_t n, int smanaged):base_t(n),man(smanaged){}
void set_managed(int sman){
man=sman;
}
~refvector(){
clear();
}
void clear() {
if(man){
iterator it=base_t::begin();
for(;it!=base_t::end();++it)
if(*it)
delete (*it);
}
base_t::clear();
}
iterator erase(iterator it){
if(man && *it)
delete (*it);
return base_t::erase(it);
}
};
template <class key_tt, class T >
class refmap: public std::map<key_tt, T * >{
protected:
int man;
public:
typedef std::map<key_tt, T * > base_t;
typedef typename base_t::iterator iterator;
typedef typename base_t::const_iterator const_iterator;
refmap(int smanaged=0):man(smanaged){}
refmap(size_t n, int smanaged=0):base_t(n),man(smanaged){}
void set_managed(int sman){
man=sman;
}
~refmap(){
clear();
}
void clear() {
if(man){
for(typename base_t::iterator i=base_t::begin();i!=base_t::end();++i)
if(i->second) delete i->second;
}
base_t::clear();
}
iterator erase(iterator it){
if(man && it->second)
delete it->second;
return base_t::erase(it);
}
};
template<class T>
class delete_ptr{
public:
void operator()(T *ptr){
delete ptr;
}
};
template<class T, class delete_t=delete_ptr<T> >
class shptr{
template<class Y, class Z> friend class shptr;
T *p;
int *num; //if num==NULL than p is not managed (as in mngptr)
void set(T *p_, int managed){
p=p_;
if(p&&managed){
num=new int;
*num=1;
}
else num=NULL;
}
template<class Y>
void set(const Y &other){
p=other.p;
if(p){
num=other.num;
if(num)(*num)++;
}
else num=NULL;
}
void set(const shptr &other){
p=other.p;
if(p){
num=other.num;
if(num)(*num)++;
}
else num=NULL;
}
public:
shptr(T* p=NULL, int managed=1){
set(p,managed);
}
shptr(const mngarg<T> &arg){
set(arg.first,arg.second);
}
template<class Y>
shptr(const Y &other){
set(other);
}
shptr(const shptr &other){
set(other);
}
void reset(T *p_, int managed=1) {
if(p!=p_){
free();
set(p_,managed);
}
}
void reset(const shptr &other) {
if(this!=&other){
free();
set(other);
}
}
const shptr &operator=(T *p) {
reset(p,0);
return *this;
}
const shptr &operator=(const mngarg<T> &arg) {
reset(arg.first,arg.second);
return *this;
}
template<class Y>
const shptr &operator=(const Y &other){
reset(other);
return *this;
}
const shptr &operator=(const shptr &other) {
reset(other);
return *this;
}
virtual ~shptr(){
free();
}
void free(){
if(p){
if(num){
(*num)--;
if((*num)==0){
delete_t()(p);
delete num;
}
num=NULL;
}
p=NULL;
}
}
bool valid() const {
return p!=NULL;
}
T* ptr() const {
return p;
}
T* operator->() const {
return p;
}
T& operator*() const{
return *p;
}
};
/*
class RefObject{
void *ref_data;
int ref_count;
public:
protected:
virtual void delete_data(void *data);
virtual void *new_data();
virtual void *copy_data(void *data);
}
class RefA: public RefObject{
public:
refA(){
ref_data = new A;
}
refA(const refA &other){
Ref(other);
}
refA& operator=(const refA &other){
if(ref_data != other.ref_data){
Ref(other);
}
return *this;
}
private:
void delete_data(void *data){
delete (A *)data;
}
void *new_data(){
return (void *)new A;
}
void *copy_data(void *data){
return (void *)(new A(*((A*)data)));
}
}*/
#endif

Event Timeline

c4science · Help