islice.h

/*
 *  Copyright (c) 2002    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_BASEKIT_ISLICE_H__
#define __INCLUDED_SCOPIRA_BASEKIT_ISLICE_H__

#include <scopira/tool/array.h>

namespace scopira
{
  namespace basekit
  {
    template <class T> class islice_vec_iterator_g;
    template <class T> class const_islice_vec_iterator_g;
    template <class T> class islice_vec_g;
  }
}

template <class T> class scopira::basekit::islice_vec_iterator_g
{
  public:
    typedef T data_type;
  private:
    T * const * dm_ptr;
  public:
    islice_vec_iterator_g(T * const * ptr) : dm_ptr(ptr) { }
    const T & operator *(void) const { return **dm_ptr; }
    bool operator ==(const islice_vec_iterator_g<T> &rhs) const { return dm_ptr == rhs.dm_ptr; }
    bool operator !=(const islice_vec_iterator_g<T> &rhs) const { return dm_ptr != rhs.dm_ptr; }

    islice_vec_iterator_g<T>& operator++(void) { dm_ptr++; return *this; }
};

template <class T> class scopira::basekit::const_islice_vec_iterator_g
{
  public:
    typedef T data_type;
  private:
    const T * const * dm_ptr;
  public:
    const_islice_vec_iterator_g(const T * const * ptr) : dm_ptr(ptr) { }
    const T & operator *(void) const { return **dm_ptr; }
    bool operator ==(const const_islice_vec_iterator_g<T> &rhs) const { return dm_ptr == rhs.dm_ptr; }
    bool operator !=(const const_islice_vec_iterator_g<T> &rhs) const { return dm_ptr != rhs.dm_ptr; }

    const_islice_vec_iterator_g<T>& operator++(void) { dm_ptr++; return *this; }
};

template <class T> class scopira::basekit::islice_vec_g : private scopira::tool::basic_array<T*>
{
  private:
    typedef scopira::tool::basic_array<T*> parent_type;
  public:
    typedef T data_type;
    typedef islice_vec_iterator_g<T> iterator;
    typedef const_islice_vec_iterator_g<T> const_iterator;

  public:
    // default default ctor - ok

    explicit islice_vec_g(size_t len) : parent_type(len) { }

    size_t size(void) const { return parent_type::size(); }
    bool empty(void) const { return parent_type::empty(); }
    void resize(size_t len) { parent_type::resize(len); }
    void clear(void) { parent_type::clear(); }

    iterator begin(void) { return islice_vec_iterator_g<T>(dm_ary); }
    iterator end(void) { return islice_vec_iterator_g<T>(dm_ary+dm_len); }
    const_iterator begin(void) const { return const_islice_vec_iterator_g<T>(dm_ary); }
    const_iterator end(void) const { return const_islice_vec_iterator_g<T>(dm_ary+dm_len); }

    template <class L>
      void copy(const L & rhs);

    void set_ptr(size_t idx, T * ref) { parent_type::set(idx, ref); }

    T &operator[](size_t idx) { return *parent_type::get(idx); }
    const T &operator[](size_t idx) const { return *parent_type::get(idx); }
    T & get(size_t idx) { return *parent_type::get(idx); }
    const T & get(size_t idx) const { return *parent_type::get(idx); }
    void set(size_t idx, const T &val) { *parent_type::get(idx) = val; }
};
template <class T> template <class L>
void scopira::basekit::islice_vec_g<T>::copy(const L &rhs)
{
  typename L::const_iterator ii;
  size_t i;
  resize( rhs.size() );
  for (i=0, ii=rhs.begin(); ii != rhs.end(); ++i, ++ii)
    set(i, *ii);
}

#endif