DB_Row_defs.hh

Go to the documentation of this file.

/* DB_Row class declaration.
   Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
   Copyright (C) 2010-2016 BUGSENG srl (http://bugseng.com)

This file is part of the Parma Polyhedra Library (PPL).

The PPL 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 3 of the License, or (at your
option) any later version.

The PPL 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 this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.

For the most up-to-date information see the Parma Polyhedra Library
site: http://bugseng.com/products/ppl/ . */

#ifndef PPL_DB_Row_defs_hh
#define PPL_DB_Row_defs_hh 1

#include "DB_Row_types.hh"
#include "globals_types.hh"
#include "Ptr_Iterator_defs.hh"
#include <cstddef>
#include <vector>

#ifndef PPL_DB_ROW_EXTRA_DEBUG
#ifdef PPL_ABI_BREAKING_EXTRA_DEBUG
#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
#define PPL_DB_ROW_EXTRA_DEBUG 1
#else // !defined(PPL_ABI_BREAKING_EXTRA_DEBUG)
#define PPL_DB_ROW_EXTRA_DEBUG 0
#endif // !defined(PPL_ABI_BREAKING_EXTRA_DEBUG)
#endif // !defined(PPL_DB_ROW_EXTRA_DEBUG)


#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename T>
class Parma_Polyhedra_Library::DB_Row_Impl_Handler {
public:
  DB_Row_Impl_Handler();

  ~DB_Row_Impl_Handler();

  class Impl;

  Impl* impl;

#if PPL_DB_ROW_EXTRA_DEBUG
  dimension_type capacity_;
#endif // PPL_DB_ROW_EXTRA_DEBUG

private:
  DB_Row_Impl_Handler(const DB_Row_Impl_Handler&);

  DB_Row_Impl_Handler& operator=(const DB_Row_Impl_Handler&);
};

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename T>
class Parma_Polyhedra_Library::DB_Row : private DB_Row_Impl_Handler<T> {
public:
  DB_Row();



  void construct(dimension_type sz);


  void construct(dimension_type sz, dimension_type capacity);


  template <typename U>
  void construct_upward_approximation(const DB_Row<U>& y,
                                      dimension_type capacity);


  DB_Row(dimension_type sz);

  DB_Row(dimension_type sz, dimension_type capacity);

  DB_Row(const DB_Row& y);


  DB_Row(const DB_Row& y, dimension_type capacity);


  DB_Row(const DB_Row& y, dimension_type sz, dimension_type capacity);

  ~DB_Row();

  DB_Row& operator=(const DB_Row& y);

  void m_swap(DB_Row& y);

  void assign(DB_Row& y);

  void allocate(dimension_type capacity);


  void expand_within_capacity(dimension_type new_size);


  void shrink(dimension_type new_size);

  static dimension_type max_size();

  dimension_type size() const;


  T& operator[](dimension_type k);

  const T& operator[](dimension_type k) const;

  typedef Implementation::Ptr_Iterator<T*> iterator;

  typedef Implementation::Ptr_Iterator<const T*> const_iterator;

  iterator begin();

  iterator end();

  const_iterator begin() const;

  const_iterator end() const;

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  memory_size_type total_memory_in_bytes(dimension_type capacity) const;

  memory_size_type external_memory_in_bytes(dimension_type capacity) const;

  bool OK(dimension_type row_size, dimension_type row_capacity) const;

private:
  template <typename U> friend class Parma_Polyhedra_Library::DB_Row;

  void copy_construct_coefficients(const DB_Row& y);

#if PPL_DB_ROW_EXTRA_DEBUG
  dimension_type capacity() const;
#endif // PPL_DB_ROW_EXTRA_DEBUG
};

namespace Parma_Polyhedra_Library {

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename T>
void swap(DB_Row<T>& x, DB_Row<T>& y);

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename T>
void iter_swap(typename std::vector<DB_Row<T> >::iterator x,
               typename std::vector<DB_Row<T> >::iterator y);

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)

template <typename T>
bool operator==(const DB_Row<T>& x, const DB_Row<T>& y);

template <typename T>
bool operator!=(const DB_Row<T>& x, const DB_Row<T>& y);
#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)

} // namespace Parma_Polyhedra_Library


#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename T>
class Parma_Polyhedra_Library::DB_Row_Impl_Handler<T>::Impl {
public:


  static void* operator new(size_t fixed_size, dimension_type capacity);

  static void operator delete(void* p);

  static void operator delete(void* p, dimension_type capacity);

  Impl();


  ~Impl();


  void expand_within_capacity(dimension_type new_size);


  void shrink(dimension_type new_size);

  void copy_construct_coefficients(const Impl& y);

  template <typename U>
  void construct_upward_approximation(const U& y);

  static dimension_type max_size();


  dimension_type size() const;

  void set_size(dimension_type new_sz);

  void bump_size();


  T& operator[](dimension_type k);

  const T& operator[](dimension_type k) const;

  memory_size_type total_memory_in_bytes() const;

  memory_size_type total_memory_in_bytes(dimension_type capacity) const;

  memory_size_type external_memory_in_bytes() const;

private:
  friend class DB_Row<T>;

  dimension_type size_;

  T vec_[
#if PPL_CXX_SUPPORTS_ZERO_LENGTH_ARRAYS
          0
#else
          1
#endif
  ];

  Impl(const Impl& y);

  Impl& operator=(const Impl&);

  void copy_construct(const Impl& y);
};

#include "DB_Row_inlines.hh"
#include "DB_Row_templates.hh"

#endif // !defined(PPL_DB_Row_defs_hh)