datablock.h

//
// Copyright (c) 2001-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Mon Mar 12 18:04:10 2001
// commit: $Id: datablock.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/mtx/datablock.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX 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.
//
// GroovX 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 for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_PKGS_MTX_DATABLOCK_H_UTC20050626084022_DEFINED
#define GROOVX_PKGS_MTX_DATABLOCK_H_UTC20050626084022_DEFINED

#include <cstddef>


//  #######################################################
//  =======================================================

struct mtx_policies
{
  enum init_policy { ZEROS, NO_INIT };
  enum storage_policy { COPY, BORROW, REFER };
};



class data_block
{
private:
  int m_refcount;

  data_block(const data_block& other); // not implemented
  data_block& operator=(const data_block& other); // not implemented

  static data_block* get_empty_data_block();

protected:
  double* const m_storage;        
  unsigned int const m_length;    


  data_block(double* data, unsigned int len);

  virtual ~data_block();

  void* operator new(size_t bytes);

  void operator delete(void* space);

  int refcount() const { return m_refcount; }

public:
  static data_block* make_zeros(int length);


  static data_block* make_uninitialized(int length);

  static data_block* make_data_copy(const double* data, int data_length);


  static data_block* make_borrowed(double* data, int data_length);


  static data_block* make_referred(double* data, int data_length);

  static data_block* make(double* data,
                          int mrows, int ncols,
                          mtx_policies::storage_policy s);

  static data_block* make(int mrows, int ncols,
                          mtx_policies::init_policy p);

  static void make_unique(data_block*& rep);

  void incr_refcount() { ++m_refcount; }

  void decr_refcount() { if (--m_refcount <= 0) delete this; }

  virtual bool is_unique() const = 0;


  const double* data()    const { return m_storage; }

        double* data_nc()       { return m_storage; }

  unsigned int  length()  const { return m_length; }
};


//  #######################################################
//  =======================================================

class data_holder : public mtx_policies
{
public:
  data_holder(double* data, int mrows, int ncols, storage_policy s);

  data_holder(int mrows, int ncols, init_policy p);

  data_holder(data_block* d);

  data_holder(const data_holder& other);

  ~data_holder();

  void swap(data_holder& other);

  void make_unique() { data_block::make_unique(m_data); }

  const double* storage() const { return m_data->data(); }

  double* storage_nc() { make_unique(); return m_data->data_nc(); }

  int storage_length() const { return m_data->length(); }

private:
  data_holder& operator=(const data_holder&); // not allowed

  data_block* m_data;
};


//  #######################################################
//  =======================================================

class data_ref_holder : public mtx_policies
{
public:
  data_ref_holder(data_holder* ref) : m_ref(ref) {}

  data_ref_holder(const data_ref_holder& other) : m_ref(other.m_ref) {}

  ~data_ref_holder() {}

  void swap(data_ref_holder& other);

  const double* storage() const { return m_ref->storage(); }

  double* storage_nc() { return m_ref->storage_nc(); }

  int storage_length() const { return m_ref->storage_length(); }

private:
  data_ref_holder& operator=(const data_ref_holder&); // not allowed

  data_holder* m_ref;
};


static const char __attribute__((used)) vcid_groovx_pkgs_mtx_datablock_h_utc20050626084022[] = "$Id: datablock.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_PKGS_MTX_DATABLOCK_H_UTC20050626084022_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:39 2008 by Doxygen version 1.5.5.