source: trunk/c++_tools/classifier/DataLookup2D.cc @ 608

// $Id$

#include <c++_tools/classifier/DataLookup2D.h>

#include <vector>

#include <cassert>
#ifndef NDEBUG
#include <algorithm>
#endif 


namespace theplu {
namespace classifier {


  DataLookup2D::DataLookup2D(const DataLookup2D& m,
                             const std::vector<size_t>& row, 
                             const std::vector<size_t>& col)
    : owner_(false)
  {
    assert(row_index_.empty());
    row_index_.reserve(row.size());
    for (size_t i=0; i<row.size(); i++) {
      assert(row[i]<m.row_index_.size());
      row_index_.push_back(m.row_index_[row[i]]);
    }
    assert(column_index_.empty());
    column_index_.reserve(col.size());
    for (size_t i=0; i<col.size(); i++) {
      assert(col[i]<m.column_index_.size());
      column_index_.push_back(m.column_index_[col[i]]);
    }
  }
    


  DataLookup2D::DataLookup2D(const DataLookup2D& m,
                             const std::vector<size_t>& index, 
                             const bool row)
    : owner_(false)
  {
    if (row){
      assert(row_index_.empty());
      row_index_.reserve(index.size());
      for (size_t i=0; i<index.size(); i++) {
        assert(index[i]<m.row_index_.size());
        row_index_.push_back(m.row_index_[index[i]]);
      }
      column_index_= m.column_index_;
    }
    else{
      assert(column_index_.empty());
      column_index_.reserve(index.size());
      for (size_t i=0; i<index.size(); i++) {
        column_index_.push_back(m.column_index_[index[i]]);
      }
      row_index_= m.row_index_;
    }
  }   


  DataLookup2D::DataLookup2D(const std::vector<size_t>& row, 
                             const std::vector<size_t>& col,
                             const bool owner)
    : row_index_(row),column_index_(col), owner_(owner)
  {
  }



  DataLookup2D::DataLookup2D(const DataLookup2D& mv)
    : row_index_(mv.row_index_),column_index_(mv.column_index_), owner_(false)
  {
  }


  DataLookup2D::DataLookup2D(const size_t rows, const size_t columns, 
                             const bool owner)
    : row_index_(std::vector<size_t>(rows,0)), 
      column_index_(std::vector<size_t>(columns,0)),
      owner_(owner)
  {
  } 

  const DataLookup2D& DataLookup2D::operator=(const DataLookup2D& other)
  {
    // never copy yourself
    if (this!=&other){
      row_index_ = other.row_index_;
      column_index_ = other.column_index_;
      owner_=false;
    }
    return *this;
  }

}} // of namespace classifier and namespace theplu