Determinate_defs.hh

Go to the documentation of this file.

/* Determinate 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_Determinate_defs_hh
#define PPL_Determinate_defs_hh

#include "Determinate_types.hh"
#include "Constraint_System_types.hh"
#include "Congruence_System_types.hh"
#include "Variable_defs.hh"
#include "globals_types.hh"
#include <iosfwd>

namespace Parma_Polyhedra_Library {


template <typename PSET>
void swap(Determinate<PSET>& x, Determinate<PSET>& y);

template <typename PSET>
bool operator==(const Determinate<PSET>& x, const Determinate<PSET>& y);

template <typename PSET>
bool operator!=(const Determinate<PSET>& x, const Determinate<PSET>& y);

namespace IO_Operators {


template <typename PSET>
std::ostream&
operator<<(std::ostream&, const Determinate<PSET>&);

} // namespace IO_Operators

} // namespace Parma_Polyhedra_Library

template <typename PSET>
class Parma_Polyhedra_Library::Determinate {
public:


  Determinate(const PSET& pset);

  Determinate(const Constraint_System& cs);

  Determinate(const Congruence_System& cgs);

  Determinate(const Determinate& y);

  ~Determinate();




  const PSET& pointset() const;

  bool is_top() const;

  bool is_bottom() const;

  bool definitely_entails(const Determinate& y) const;

  bool is_definitely_equivalent_to(const Determinate& y) const;

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  static bool has_nontrivial_weakening();

  bool OK() const;





  void upper_bound_assign(const Determinate& y);

  void meet_assign(const Determinate& y);

  void weakening_assign(const Determinate& y);

  void concatenate_assign(const Determinate& y);

  PSET& pointset();

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  void mutate();

  Determinate& operator=(const Determinate& y);

  void m_swap(Determinate& y);


#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  template <typename Binary_Operator_Assign>
  class Binary_Operator_Assign_Lifter {
  public:
    explicit
    Binary_Operator_Assign_Lifter(Binary_Operator_Assign op_assign);

    void operator()(Determinate& x, const Determinate& y) const;

  private:
    Binary_Operator_Assign op_assign_;
  };

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  template <typename Binary_Operator_Assign>
  static Binary_Operator_Assign_Lifter<Binary_Operator_Assign>
  lift_op_assign(Binary_Operator_Assign op_assign);

private:

  class Rep {
  private:
    mutable unsigned long references;

    Rep& operator=(const Rep& y);

    Rep(const Rep& y);

    Rep();

  public:
    PSET pset;

    Rep(dimension_type num_dimensions, Degenerate_Element kind);

    Rep(const PSET& p);

    Rep(const Constraint_System& cs);

    Rep(const Congruence_System& cgs);

    ~Rep();

    void new_reference() const;

    bool del_reference() const;

    bool is_shared() const;

    memory_size_type total_memory_in_bytes() const;

    memory_size_type external_memory_in_bytes() const;
  };

  Rep* prep;

  friend bool
  operator==<PSET>(const Determinate<PSET>& x, const Determinate<PSET>& y);

  friend bool
  operator!=<PSET>(const Determinate<PSET>& x, const Determinate<PSET>& y);
};

#include "Determinate_inlines.hh"

#endif // !defined(PPL_Determinate_defs_hh)