binary_index_block.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 binary_index_block

#ifndef BINARY_INDEX_BLOCK_H
#define BINARY_INDEX_BLOCK_H

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

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

namespace sheaf
{
  
template <typename T>
class binary_index_block : public block<T>
{

public:

  // ===========================================================
  // ANY FACET
  // ===========================================================

  binary_index_block& operator=(const binary_index_block& xother);

  bool invariant() const;

  // ===========================================================
  // BLOCK FACET
  // ===========================================================

  using block<T>::push_back;

  void push_back(const binary_index_block& xother);

  // ===========================================================
  // BINARY_INDEX_BLOCK FACET
  // ===========================================================

  binary_index_block(int xi_ub = 0, int xj_ub = 0);

  binary_index_block(const binary_index_block& xother);


  binary_index_block(int xi_ub, int xi_ct, int xj_ub, int xj_ct, const T *xitems);

  ~binary_index_block();

  int i_ub() const;

  int j_ub() const;

  int i_ct() const;

  int j_ct() const;

  using block<T>::item;

  T& item(int xi, int xj);

  const T& item(int xi, int xj) const;

  T* operator [] (int xi) const;

  using block<T>::force_item;

  void force_item(int xi, int xj, const T& xitem);

  using block<T>::reserve;

  void reserve(int xi_ub, int xj_ub);

  using block<T>::set_ct;

  void set_ct(int xi_ct, int xj_ct);

  void put_item(int xi, int xj, const T& xitem);

  void assign(const T& xitem);

protected:

  int _i_ub;

  int _j_ub;

  int _i_ct;

  int _j_ct;


};

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

template <class T>
std::ostream&
operator << (std::ostream& xos, const binary_index_block<T>& xblk);
 
} // namespace sheaf


#endif // ifndef BINARY_INDEX_BLOCK_H