ragged_array.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

// Interface for class ragged_array

#ifndef RAGGED_ARRAY_H
#define RAGGED_ARRAY_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef RC_ANY_H
#include "SheafSystem/rc_any.h"
#endif

#ifndef RC_PTR_H
#include "SheafSystem/rc_ptr.h"
#endif

#ifndef BLOCK_H
#include "SheafSystem/block.h"
#endif

namespace sheaf
{
  
template <typename T> class ragged_array;

template<typename T>
size_t deep_size(const ragged_array<T>& xra, bool xinclude_shallow = true);

template <typename T>
class SHEAF_DLL_SPEC ragged_array : public rc_any
{

  friend size_t deep_size<T>(const ragged_array<T>& xra, bool xinclude_shallow); 

  // ===========================================================
  // ===========================================================

public:

  typedef unsigned long index_type;


  typedef rc_ptr< ragged_array<T> > ptr;

  ragged_array(size_t xct = 0);

  ragged_array(const ragged_array& xother);

  ragged_array(const index_type* xcol_cts,
               index_type xcol_cts_ub);

  ragged_array(const index_type xrow_ct, const index_type xvalue_ct);

  virtual ~ragged_array();

  ragged_array& operator=(const ragged_array& xother);

  virtual bool operator==(const ragged_array& xother) const;

  index_type row_ct() const;

  index_type col_ct(const index_type xrow_index) const;

  index_type* col_cts() const;

  T* values() const;

  index_type value_ct() const;

  T* row(const index_type xrow_index) const;

  T* operator[](const index_type xrow_index) const;

  void reset_rows();

  void reset_rows(const index_type* xcol_cts, const index_type xcol_cts_ub);

  index_type sum_col_cts() const;

  index_type sum_col_cts(const index_type* xcol_cts, const index_type xcol_cts_ub) const;

  void initialize_push_back(index_type xrow_ct, index_type xvalue_ct);

  index_type back_row() const;

  void new_back_row();

  void push_back(const T& xvalue);

protected:

  void initialize(const index_type* xcol_cts,
                  index_type xcol_cts_ub);


  block<T> _values;

  block<index_type> _col_cts;

  block<index_type> _row_ptrs;

private:



  // ===========================================================
  // ===========================================================

public:

  virtual ragged_array* clone() const;

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* xother) const;

protected:

private:

};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================

template <typename T>
std::ostream& operator << (std::ostream& xos, const ragged_array<T>& xra);
 
} // namespace sheaf

#endif // ifndef RAGGED_ARRAY_H