OpendTect  6.6
typeset.h
Go to the documentation of this file.
1 #pragma once
2 
3 /*+
4 ________________________________________________________________________
5 
6  (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
7  Author: Bert / many others
8  Date: Apr 1995 / Feb 2009
9 RCS: $Id:$
10 ________________________________________________________________________
11 
12 -*/
13 
14 #include "odset.h"
15 #include "vectoraccess.h"
16 
17 
20 namespace OD
21 {
22 
23 template <class T, class IT>
24 mClass(Basic) ValVec : public Set
25 {
26 public:
27 
28  typedef IT size_type;
29  typedef size_type idx_type;
30  typedef T object_type;
31 
32  ValVec* clone() const = 0;
33  inline virtual ~ValVec();
34  inline ValVec& operator =( const ValVec& oth )
35  { return copy( oth ); }
36  inline bool operator==(const ValVec&) const;
37  inline bool operator!=( const ValVec& oth ) const
38  { return !(*this == oth); }
39 
40  inline size_type size() const;
41  inline virtual od_int64 nrItems() const { return size(); }
42  inline virtual bool setSize(size_type,T val=T());
44  inline virtual bool setCapacity(size_type sz,bool withmargin);
46  inline virtual size_type getCapacity() const;
47  inline void setAll(T);
48  inline void replace(T,T);
49 
50  inline T& get(idx_type);
51  inline const T& get(idx_type) const;
52  inline T& first();
53  inline const T& first() const;
54  inline T& last();
55  inline const T& last() const;
56  inline virtual bool validIdx(od_int64) const;
57  inline virtual idx_type indexOf(T,bool forward=true,
58  idx_type start=-1) const;
59  inline bool isPresent(const T&) const;
60  inline size_type count(const T&) const;
61 
62  inline ValVec& add(const T&);
63  inline virtual void insert(idx_type,const T&);
64  inline bool push(const T&);
65  inline T pop();
66  inline virtual bool append(const T*,size_type);
67  inline virtual bool append(const ValVec&);
68  inline virtual bool addIfNew(const T&);
69  inline void swap(IT,IT);
70  inline virtual ValVec& copy(const T*,size_type);
71  inline virtual ValVec& copy(const ValVec&);
72  virtual inline void createUnion(const ValVec&);
74  virtual inline void createIntersection(const ValVec&);
76  virtual inline void createDifference(const ValVec&,
77  bool must_preserve_order=false);
79 
80  inline virtual void swapItems( od_int64 i1, od_int64 i2 )
81  { swap( (IT)i1, (IT)i2 ); }
82  inline virtual void move(idx_type from,idx_type to);
83  inline virtual void useIndexes(const idx_type*);
84 
85  inline virtual void reverse();
86 
87  inline virtual void erase();
88  inline virtual void removeSingle(idx_type,
89  bool preserver_order=true);
90  inline virtual void removeRange(idx_type from,idx_type to);
91 
93  inline virtual T* arr() { return gtArr(); }
94  inline virtual const T* arr() const { return gtArr(); }
95  inline std::vector<T>& vec();
96  inline const std::vector<T>& vec() const;
97 
98  inline T& operator[](idx_type i) { return get(i); }
99  inline const T& operator[](idx_type i) const { return get(i); }
100  inline ValVec& operator+=(const T& t) { return add(t); }
101  inline ValVec& operator-=(const T& t);
102 
103 protected:
104 
105  inline ValVec();
106  inline ValVec(size_type nr,T typ);
107  inline ValVec(const T*,size_type nr);
108  inline ValVec(const ValVec&);
109 
110  typedef VectorAccess<T,IT> impl_type;
111  impl_type vec_;
112 
113  inline T* gtArr() const;
114 
115 public:
116 
117  // Compat with std containers
118  typedef T value_type;
119  typedef value_type& reference;
120  typedef const value_type& const_reference;
121  typedef typename impl_type::iterator iterator;
122  typedef typename impl_type::const_iterator const_iterator;
123  typedef size_type difference_type;
124 
125  iterator begin() { return vec_.begin(); }
126  const_iterator begin() const { return vec_.cbegin(); }
127  const_iterator cbegin() const { return vec_.cbegin(); }
128  iterator end() { return vec_.end(); }
129  const_iterator end() const { return vec_.cend(); }
130  const_iterator cend() const { return vec_.cend(); }
131  inline size_type max_size() const { return maxIdx32(); }
132  inline bool empty() const { return isEmpty(); }
133  inline void swap( ValVec& oth ) { vec_.swap(oth.vec_); }
134 
135  // Usability
136  idx_type getIdx( iterator it ) const { return vec_.getIdx(it); }
137  idx_type getIdx( const_iterator it ) const { return vec_.getIdx(it); }
138 
139 };
140 
141 } // namespace OD
142 
143 
144 #define mDefTypeSetClass( clss, idxtype ) \
145 template <class T> \
146 mClass(Basic) clss : public OD::ValVec<T,idxtype> \
147 { \
148 public: \
149  \
150  typedef typename OD::ValVec<T,idxtype>::idx_type idx_type; \
151  typedef typename OD::ValVec<T,idxtype>::size_type size_type; \
152  \
153  clss() \
154  : OD::ValVec<T,size_type>() {} \
155  clss( size_type nr, T typ ) \
156  : OD::ValVec<T,size_type>( nr, typ ) {} \
157  explicit clss( T typ ) \
158  : OD::ValVec<T,size_type>( 1, typ ) {} \
159  clss( const T* t, size_type nr ) \
160  : OD::ValVec<T,size_type>( t, nr ) {} \
161  clss( const clss& oth ) \
162  : OD::ValVec<T,size_type>( oth ) {} \
163  virtual clss* clone() const { return new clss(*this); } \
164 }; \
165  \
166 template <class T> \
167 mGlobal(Basic) inline void swap( clss<T>& vv1, clss<T>& vv2 ) \
168 { \
169  vv1.swap( vv2 ); \
170 }
171 
172 
185 mDefTypeSetClass( TypeSet, od_int32 )
186 mDefTypeSetClass( LargeValVec, od_int64 )
187 
188 
191 mClass(Basic) BoolTypeSetType
192 {
193 public:
194 
195  BoolTypeSetType( bool v=false )
196  : val_( v ) {}
197 
198  operator bool() const { return bool(val_); }
199  bool operator=( bool v ) { val_ = v; return v; }
200 
201 protected:
202 
203  char val_;
204 
205 };
206 
207 typedef TypeSet<BoolTypeSetType> BoolTypeSet;
208 typedef LargeValVec<BoolTypeSetType> BoolLargeValVec;
209 
210 
211 
212 template <class T, class IT>
213 inline bool operator ==( const OD::ValVec<T,IT>& a, const OD::ValVec<T,IT>& b )
214 {
215  return a.operator ==( b );
216 }
217 
218 template <class T,class IT> inline
219 bool OD::ValVec<T,IT>::operator ==( const OD::ValVec<T,IT>& oth ) const
220 {
221  const IT sz = size();
222  if ( sz != oth.size() )
223  return false;
224 
225  for ( IT vidx=0; vidx<sz; vidx++ )
226  if ( !(get(vidx) == oth.get(vidx)) )
227  return false;
228 
229  return true;
230 }
231 
232 template <class T, class IT>
233 inline bool operator !=( const OD::ValVec<T,IT>& a, const OD::ValVec<T,IT>& b)
234 { return !(a == b); }
235 
236 
238 template <class T, class IT, class J, class S>
239 inline bool append( OD::ValVec<T,IT>& to, const OD::ValVec<S,J>& from )
240 {
241  const J sz = from.size();
242  if ( !to.setCapacity( sz + to.size(), true ) )
243  return false;
244 
245  for ( J vidx=0; vidx<sz; vidx++ )
246  to.add( (T)from.get(vidx) );
247 
248  return true;
249 }
250 
251 
254 template <class T, class IT,class S>
255 inline void copy( OD::ValVec<T,IT>& to, const OD::ValVec<S,IT>& from )
256 {
257  if ( (void*)(&to) == (void*)(&from) ) return;
258  to.erase();
259  append( to, from );
260 }
261 
262 
264 template <class T, class IT> inline
265 typename OD::ValVec<T,IT>::idx_type* getSortIndexes( OD::ValVec<T,IT>& vv,
266  bool ascending=true )
267 {
268  typedef typename OD::ValVec<T,IT>::idx_type idx_type;
269  const IT sz = vv.size();
270  if ( sz < 2 )
271  { idx_type* ret = new int [1]; *ret = 0; return ret; }
272 
273  mGetIdxArr( idx_type, idxs, sz );
274 
275  for ( IT d=sz/2; d>0; d=d/2 )
276  for ( IT i=d; i<sz; i++ )
277  for ( IT j=i-d; j>=0 && vv[idxs[j]]>vv[idxs[j+d]]; j-=d )
278  std::swap( idxs[j], idxs[j+d] );
279 
280  if ( !ascending )
281  std::reverse( idxs, idxs+sz );
282 
283  return idxs;
284 }
285 
286 
288 template <class T, class IT>
289 inline void sort( OD::ValVec<T,IT>& vv )
290 {
291  T tmp; const IT sz = vv.size();
292  for ( IT d=sz/2; d>0; d=d/2 )
293  for ( IT i=d; i<sz; i++ )
294  for ( IT j=i-d; j>=0 && vv[j]>vv[j+d]; j-=d )
295  { tmp = vv[j]; vv[j] = vv[j+d]; vv[j+d] = tmp; }
296 }
297 
298 
299 // Member function implementations
300 template <class T, class IT> inline
301 OD::ValVec<T,IT>::ValVec()
302 {}
303 
304 template <class T, class IT> inline
305 OD::ValVec<T,IT>::ValVec( IT nr, T typ )
306 { setSize( nr, typ ); }
307 
308 template <class T, class IT> inline
309 OD::ValVec<T,IT>::ValVec( const T* tarr, IT nr )
310 { append( tarr, nr ); }
311 
312 template <class T, class IT> inline
313 OD::ValVec<T,IT>::ValVec( const OD::ValVec<T,IT>& t )
314  : OD::Set( t )
315 { append( t ); }
316 
317 template <class T, class IT> inline
318 OD::ValVec<T,IT>::~ValVec() {}
319 
320 template <class T, class IT> inline
321 IT OD::ValVec<T,IT>::size() const
322 { return vec_.size(); }
323 
324 template <class T, class IT> inline
325 bool OD::ValVec<T,IT>::setSize( IT sz, T val )
326 { return vec_.setSize( sz, val ); }
327 
328 template <class T, class IT> inline
329 IT OD::ValVec<T,IT>::getCapacity() const
330 { return vec_.getCapacity(); }
331 
332 template <class T, class IT> inline
333 bool OD::ValVec<T,IT>::setCapacity( IT sz, bool withmargin )
334 { return vec_.setCapacity( sz, withmargin ); }
335 
336 template <class T, class IT> inline
337 void OD::ValVec<T,IT>::setAll( T val )
338 { vec_.fillWith( val ); }
339 
340 template <class T, class IT> inline
341  void OD::ValVec<T,IT>::replace( T val, T newval )
342 { vec_.replace( val, newval ); }
343 
344 
345 template <class T, class IT> inline
346 bool OD::ValVec<T,IT>::validIdx( od_int64 vidx ) const
347 { return vec_.validIdx( sCast(IT,vidx) ); }
348 
349 template <class T, class IT> inline
350 T& OD::ValVec<T,IT>::get( IT vidx )
351 {
352 #ifdef __debug__
353  if ( !validIdx(vidx) )
354  DBG::forceCrash(true);
355 #endif
356  return vec_[vidx];
357 }
358 
359 template <class T, class IT> inline
360 const T& OD::ValVec<T,IT>::get( IT vidx ) const
361 {
362 #ifdef __debug__
363  if ( !validIdx(vidx) )
364  DBG::forceCrash(true);
365 #endif
366  return vec_[vidx];
367 }
368 
369 template <class T, class IT> inline
370 T& OD::ValVec<T,IT>::first()
371 { return vec_.first(); }
372 
373 template <class T, class IT> inline
374 const T& OD::ValVec<T,IT>::first() const
375 { return vec_.first(); }
376 
377 template <class T, class IT> inline
378 T& OD::ValVec<T,IT>::last()
379 { return vec_.last(); }
380 
381 template <class T, class IT> inline
382 const T& OD::ValVec<T,IT>::last() const
383 { return vec_.last(); }
384 
385 template <class T, class IT> inline
386 T OD::ValVec<T,IT>::pop()
387 { return vec_.pop_back(); }
388 
389 template <class T, class IT> inline
390 IT OD::ValVec<T,IT>::indexOf( T typ, bool forward, IT start ) const
391 { return vec_.indexOf( typ, forward, start ); }
392 
393 template <class T, class IT> inline
394 bool OD::ValVec<T,IT>::isPresent( const T& t ) const
395 { return vec_.isPresent(t); }
396 
397 template <class T, class IT> inline
398 IT OD::ValVec<T,IT>::count( const T& typ ) const
399 { return vec_.count( typ ); }
400 
401 template <class T, class IT> inline
402 OD::ValVec<T,IT>& OD::ValVec<T,IT>::add( const T& typ )
403 { vec_.push_back( typ ); return *this; }
404 
405 template <class T, class IT> inline
406 bool OD::ValVec<T,IT>::push( const T& typ )
407 { return vec_.push_back( typ ); }
408 
409 template <class T, class IT> inline
410 OD::ValVec<T,IT>& OD::ValVec<T,IT>::operator -=( const T& typ )
411 { vec_.erase( typ ); return *this; }
412 
413 template <class T, class IT> inline
414 OD::ValVec<T,IT>& OD::ValVec<T,IT>::copy( const OD::ValVec<T,IT>& oth )
415 { return this == &oth ? *this : copy( oth.arr(), oth.size() ); }
416 
417 template <class T, class IT> inline
418 void OD::ValVec<T,IT>::erase()
419 { vec_.erase(); }
420 
421 template <class T, class IT> inline
422 void OD::ValVec<T,IT>::removeRange( IT i1, IT i2 )
423 { vec_.remove( i1, i2 ); }
424 
425 template <class T, class IT> inline
426 void OD::ValVec<T,IT>::insert( IT vidx, const T& typ )
427 { vec_.insert( vidx, typ );}
428 
429 template <class T, class IT> inline
430 std::vector<T>& OD::ValVec<T,IT>::vec()
431 { return vec_.vec(); }
432 
433 template <class T, class IT> inline
434 const std::vector<T>& OD::ValVec<T,IT>::vec() const
435 { return vec_.vec(); }
436 
437 template <class T, class IT> inline
438 T* OD::ValVec<T,IT>::gtArr() const
439 {
440  return isEmpty() ? nullptr : const_cast<T*>( &first() );
441 }
442 
443 
444 template <class T, class IT> inline
445 void OD::ValVec<T,IT>::swap( IT idx1, IT idx2 )
446 {
447  if ( !validIdx(idx1) || !validIdx(idx2) )
448  {
449 #ifdef __debug__
450  DBG::forceCrash(true);
451 #endif
452  return;
453  }
454  vec_.swapElems( idx1, idx2 );
455 }
456 
457 
458 template <class T, class IT> inline
459 void OD::ValVec<T,IT>::useIndexes( const idx_type* idxs )
460 {
461  const size_type sz = size();
462  if ( idxs && sz > 1 )
463  {
464  ValVec* tmp = clone();
465  for ( size_type idx=0; idx<sz; idx++ )
466  get(idx) = tmp->get( idxs[idx] );
467  delete tmp;
468  }
469 }
470 
471 
472 template <class T, class IT> inline
473 void OD::ValVec<T,IT>::move( IT idxfrom, IT idxto )
474 {
475  if ( !validIdx(idxfrom) || !validIdx(idxto) )
476  return;
477 
478  T tmp = vec_[idxfrom];
479  insert( idxto, tmp );
480  vec_.remove( idxfrom < idxto ? idxfrom : idxfrom+1 );
481 }
482 
483 
484 template <class T, class IT> inline
485 void OD::ValVec<T,IT>::reverse()
486 {
487  const IT sz = size();
488  const IT hsz = sz/2;
489  for ( IT vidx=0; vidx<hsz; vidx++ )
490  swap( vidx, sz-1-vidx );
491 }
492 
493 
494 template <class T, class IT> inline
495 OD::ValVec<T,IT>& OD::ValVec<T,IT>::copy( const T* tarr, IT sz )
496 {
497  if ( size() != sz )
498  { erase(); append(tarr,sz); }
499  else
500  {
501  for ( IT vidx=0; vidx<sz; vidx++ )
502  get(vidx) = tarr[vidx];
503  }
504  return *this;
505 }
506 
507 
508 template <class T, class IT> inline
509 bool OD::ValVec<T,IT>::append( const OD::ValVec<T,IT>& oth )
510 {
511  if ( this != &oth )
512  return append( oth.arr(), oth.size() );
513 
514  const ValVec* cln = clone();
515  const bool ret = append( *cln );
516  delete cln;
517  return ret;
518 }
519 
520 
521 template <class T, class IT> inline
522 bool OD::ValVec<T,IT>::append( const T* tarr, IT sz )
523 {
524  if ( !sz ) return true;
525 
526  if ( !setCapacity( sz+size(), true ) )
527  return false;
528 
529  for ( IT vidx=0; vidx<sz; vidx++ )
530  add( tarr[vidx] );
531 
532  return true;
533 }
534 
535 
536 template <class T, class IT>
537 inline void OD::ValVec<T,IT>::createUnion( const OD::ValVec<T,IT>& oth )
538 {
539  const IT sz = oth.size();
540  const T* ptr = oth.arr();
541  for ( IT vidx=0; vidx<sz; vidx++, ptr++ )
542  addIfNew( *ptr );
543 }
544 
545 
546 template <class T, class IT>
547 inline void OD::ValVec<T,IT>::createIntersection( const OD::ValVec<T,IT>& oth )
548 {
549  for ( IT vidx=0; vidx<size(); vidx++ )
550  {
551  if ( oth.isPresent((*this)[vidx]) )
552  continue;
553  removeSingle( vidx--, false );
554  }
555 }
556 
557 
558 template <class T, class IT>
559 inline void OD::ValVec<T,IT>::createDifference( const OD::ValVec<T,IT>& oth,
560  bool kporder )
561 {
562  const IT sz = oth.size();
563  for ( IT vidx=0; vidx<sz; vidx++ )
564  {
565  const T typ = oth[vidx];
566  for ( IT idy=0; idy<size(); idy++ )
567  {
568  if ( vec_[idy] == typ )
569  removeSingle( idy--, kporder );
570  }
571  }
572 }
573 
574 
575 template <class T, class IT> inline
576 bool OD::ValVec<T,IT>::addIfNew( const T& typ )
577 {
578  if ( !isPresent(typ) )
579  { *this += typ; return true; }
580  return false;
581 }
582 
583 
584 template <class T, class IT> inline
585 void OD::ValVec<T,IT>::removeSingle( IT vidx, bool kporder )
586 {
587  if ( kporder )
588  vec_.remove( vidx );
589  else
590  {
591  const IT lastidx = size()-1;
592  if ( vidx != lastidx )
593  vec_[vidx] = vec_[lastidx];
594  vec_.remove( lastidx );
595  }
596 }
597 
598 
599 
600  //--- useful for iterating over any OD::Set
601 template <class T,class IT>
602 mGlobal(Basic) inline T& getRef( OD::ValVec<T,IT>& vv, IT i )
603 { return vv.get( i ); }
604 template <class T,class IT>
605 mGlobal(Basic) inline const T& getRef( const OD::ValVec<T,IT>& vv, IT i )
606 { return vv.get( i ); }
getRef
T & getRef(OD::ValVec< T, IT > &vv, IT i)
Definition: typeset.h:602
VectorAccess::cbegin
const_iterator cbegin() const
Definition: vectoraccess.h:50
VectorAccess::getIdx
idx_type getIdx(iterator it) const
Definition: vectoraccess.h:54
BoolTypeSetType::val_
char val_
Definition: typeset.h:203
OD::ValVec::cbegin
const_iterator cbegin() const
Definition: typeset.h:127
OD::ValVec::swap
void swap(IT, IT)
Definition: typeset.h:445
OD::ValVec::end
const_iterator end() const
Definition: typeset.h:129
OD::ValVec::value_type
T value_type
Definition: typeset.h:118
Conv::to
T to(const F &fr)
Definition: convert.h:34
OD::ValVec::push
bool push(const T &)
Definition: typeset.h:406
sort
void sort(OD::ValVec< T, IT > &vv)
Sort OD::ValVec. Must have operator > defined for elements.
Definition: typeset.h:289
OD::ValVec::operator==
bool operator==(const ValVec &) const
Definition: typeset.h:219
mGlobal
#define mGlobal(module)
Definition: commondefs.h:180
BoolTypeSetType::operator=
bool operator=(bool v)
Definition: typeset.h:199
OD::ValVec::setCapacity
virtual bool setCapacity(size_type sz, bool withmargin)
Definition: typeset.h:333
OD::ValVec::begin
iterator begin()
Definition: typeset.h:125
OD::ValVec::size_type
IT size_type
Definition: typeset.h:28
OD::ValVec::const_reference
const value_type & const_reference
Definition: typeset.h:120
od_int64
#define od_int64
Definition: plftypes.h:35
OD::ValVec::iterator
impl_type::iterator iterator
Definition: typeset.h:121
VectorAccess< T, int64_t >::iterator
impl_type::iterator iterator
Definition: vectoraccess.h:45
OD
OpendTect.
Definition: commontypes.h:28
VectorAccess
Simple vector-based container simplifying index-based work.
Definition: vectoraccess.h:38
OD::ValVec::ValVec
ValVec(size_type nr, T typ)
Definition: typeset.h:305
sCast
#define sCast(tp, v)
Definition: commondefs.h:141
odset.h
OD::ValVec::begin
const_iterator begin() const
Definition: typeset.h:126
OD::ValVec::validIdx
virtual bool validIdx(int64_t) const
Definition: typeset.h:346
OD::ValVec::removeRange
virtual void removeRange(idx_type from, idx_type to)
Definition: typeset.h:422
OD::ValVec::createDifference
virtual void createDifference(const ValVec &, bool must_preserve_order=false)
Removes all items present in other set.
Definition: typeset.h:559
OD::ValVec::vec
std::vector< T > & vec()
Definition: typeset.h:430
OD::ValVec::cend
const_iterator cend() const
Definition: typeset.h:130
OD::ValVec::setAll
void setAll(T)
Definition: typeset.h:337
OD::ValVec::useIndexes
virtual void useIndexes(const idx_type *)
Definition: typeset.h:459
isEmpty
bool isEmpty(const NLAModel *mdl)
OD::ValVec::vec_
impl_type vec_
Definition: typeset.h:111
OD::ValVec::indexOf
virtual idx_type indexOf(T, bool forward=true, idx_type start=-1) const
Definition: typeset.h:390
OD::ValVec::replace
void replace(T, T)
Definition: typeset.h:341
OD::ValVec::first
T & first()
Definition: typeset.h:370
VectorAccess::cend
const_iterator cend() const
Definition: vectoraccess.h:53
OD::ValVec::ValVec
ValVec(const T *, size_type nr)
Definition: typeset.h:309
OD::ValVec::arr
virtual const T * arr() const
Definition: typeset.h:94
OD::ValVec::createIntersection
virtual void createIntersection(const ValVec &)
Only keeps common items.
Definition: typeset.h:547
mGetIdxArr
#define mGetIdxArr(tp, var, sz)
Creates new array of an integer type filled with index.
Definition: commondefs.h:258
OD::ValVec::getCapacity
virtual size_type getCapacity() const
Definition: typeset.h:329
OD::ValVec::operator!=
bool operator!=(const ValVec &oth) const
Definition: typeset.h:37
OD::ValVec::vec
const std::vector< T > & vec() const
Definition: typeset.h:434
OD::ValVec::operator[]
const T & operator[](idx_type i) const
Definition: typeset.h:99
OD::ValVec::last
T & last()
Definition: typeset.h:378
OD::ValVec::clone
ValVec * clone() const =0
OD::ValVec::append
virtual bool append(const ValVec &)
Definition: typeset.h:509
swap
void swap(TypeSet< T > &vv1, TypeSet< T > &vv2)
Definition: typeset.h:185
OD::ValVec::const_iterator
impl_type::const_iterator const_iterator
Definition: typeset.h:122
OD::ValVec::~ValVec
virtual ~ValVec()
Definition: typeset.h:318
OD::ValVec::impl_type
VectorAccess< T, IT > impl_type
Definition: typeset.h:110
BoolTypeSet
TypeSet< BoolTypeSetType > BoolTypeSet
Definition: typeset.h:207
mClass
#define mClass(module)
Definition: commondefs.h:181
OD::ValVec::swapItems
virtual void swapItems(int64_t i1, int64_t i2)
Definition: typeset.h:80
VectorAccess< T, int64_t >::const_iterator
impl_type::const_iterator const_iterator
Definition: vectoraccess.h:46
OD::ValVec::gtArr
T * gtArr() const
Definition: typeset.h:438
VectorAccess::swap
void swap(VectorAccess &oth)
Definition: vectoraccess.h:120
OD::ValVec::operator-=
ValVec & operator-=(const T &t)
Definition: typeset.h:410
OD::ValVec::count
size_type count(const T &) const
Definition: typeset.h:398
OD::ValVec::last
const T & last() const
Definition: typeset.h:382
OD::ValVec::operator[]
T & operator[](idx_type i)
Definition: typeset.h:98
BoolTypeSetType::BoolTypeSetType
BoolTypeSetType(bool v=false)
Definition: typeset.h:195
OD::ValVec::idx_type
size_type idx_type
Definition: typeset.h:29
OD::ValVec::ValVec
ValVec()
Definition: typeset.h:301
operator!=
bool operator!=(const OD::ValVec< T, IT > &a, const OD::ValVec< T, IT > &b)
Definition: typeset.h:233
vectoraccess.h
OD::ValVec::empty
bool empty() const
Definition: typeset.h:132
VectorAccess::end
iterator end()
Definition: vectoraccess.h:51
OD::ValVec::getIdx
idx_type getIdx(iterator it) const
Definition: typeset.h:136
OD::ValVec::removeSingle
virtual void removeSingle(idx_type, bool preserver_order=true)
Definition: typeset.h:585
operator==
bool operator==(const OD::ValVec< T, IT > &a, const OD::ValVec< T, IT > &b)
Definition: typeset.h:213
OD::ValVec::setSize
virtual bool setSize(size_type, T val=T())
Definition: typeset.h:325
VectorAccess::begin
iterator begin()
Definition: vectoraccess.h:48
copy
void copy(OD::ValVec< T, IT > &to, const OD::ValVec< S, IT > &from)
Definition: typeset.h:255
OD::ValVec::end
iterator end()
Definition: typeset.h:128
BoolTypeSetType
Needed because the std lib has a crazy specialisation vector<bool>.
Definition: typeset.h:192
OD::ValVec::isPresent
bool isPresent(const T &) const
Definition: typeset.h:394
OD::ValVec::pop
T pop()
Definition: typeset.h:386
OD::ValVec::difference_type
size_type difference_type
Definition: typeset.h:123
OD::ValVec::arr
virtual T * arr()
3rd party access
Definition: typeset.h:93
OD::ValVec::add
ValVec & add(const T &)
Definition: typeset.h:402
OD::ValVec::get
const T & get(idx_type) const
Definition: typeset.h:360
OD::ValVec::reverse
virtual void reverse()
Definition: typeset.h:485
OD::ValVec::ValVec
ValVec(const ValVec &)
Definition: typeset.h:313
od_int32
#define od_int32
Definition: plftypes.h:30
OD::ValVec::first
const T & first() const
Definition: typeset.h:374
OD::ValVec::swap
void swap(ValVec &oth)
Definition: typeset.h:133
OD::ValVec::operator+=
ValVec & operator+=(const T &t)
Definition: typeset.h:100
OD::ValVec::max_size
size_type max_size() const
Definition: typeset.h:131
OD::ValVec::copy
virtual ValVec & copy(const ValVec &)
Definition: typeset.h:414
OD::ValVec::append
virtual bool append(const T *, size_type)
Definition: typeset.h:522
OD::ValVec::nrItems
virtual int64_t nrItems() const
Definition: typeset.h:41
OD::ValVec
Definition: typeset.h:25
OD::ValVec::erase
virtual void erase()
Definition: typeset.h:418
OD::ValVec::get
T & get(idx_type)
Definition: typeset.h:350
OD::ValVec::size
size_type size() const
Definition: typeset.h:321
OD::ValVec::copy
virtual ValVec & copy(const T *, size_type)
Definition: typeset.h:495
append
bool append(OD::ValVec< T, IT > &to, const OD::ValVec< S, J > &from)
append allowing a different type to be merged into set
Definition: typeset.h:239
OD::ValVec::object_type
T object_type
Definition: typeset.h:30
BoolLargeValVec
LargeValVec< BoolTypeSetType > BoolLargeValVec
Definition: typeset.h:208
DBG::forceCrash
void forceCrash(bool withdump)
OD::ValVec::insert
virtual void insert(idx_type, const T &)
Definition: typeset.h:426
OD::ValVec::reference
value_type & reference
Definition: typeset.h:119
getSortIndexes
OD::ValVec< T, IT >::idx_type * getSortIndexes(OD::ValVec< T, IT > &vv, bool ascending=true)
Get sort indexes. Must have operator > defined for elements.
Definition: typeset.h:265
mDefTypeSetClass
#define mDefTypeSetClass(clss, idxtype)
Definition: typeset.h:144
OD::ValVec::createUnion
virtual void createUnion(const ValVec &)
Definition: typeset.h:537
LargeValVec
Definition: typeset.h:186
OD::ValVec::getIdx
idx_type getIdx(const_iterator it) const
Definition: typeset.h:137
OD::ValVec::move
virtual void move(idx_type from, idx_type to)
Definition: typeset.h:473
TypeSet
Sets of (small) copyable elements.
Definition: commontypes.h:29
OD::Set
Base class for all sets used in OpendTect.
Definition: odset.h:33
OD::ValVec::addIfNew
virtual bool addIfNew(const T &)
Definition: typeset.h:576

Generated at for the OpendTect seismic interpretation project. Copyright (C): dGB Beheer B.V. 1995-2021