/home/mine/apron/apronxx/apxx_tcons0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_tcons0.hh
 *
 * APRON Library / C++ class wrappers
 *
 * Copyright (C) Antoine Mine' 2007
 *
 */
/* This file is part of the APRON Library, released under LGPL license
   with an exception allowing the redistribution of statically linked
   executables.
  
   Please read the COPYING file packaged in the distribution.
*/

#ifndef __APXX_TCONS0_HH
#define __APXX_TCONS0_HH

#include "ap_tcons0.h"
#include "apxx_texpr0.hh"
#include "apxx_lincons0.hh"


namespace apron {

/* ================================= */
/* tcons0                            */
/* ================================= */


class tcons0 : public use_malloc {

protected:
  
  ap_tcons0_t l;  

  tcons0(ap_tcons0_t& l);

  friend class abstract0;
  
public:

  
  /* constructors */
  /* ============ */


  tcons0(ap_constyp_t constyp=AP_CONS_SUPEQ);

  tcons0(ap_constyp_t constyp, const texpr0::builder& t);

  tcons0(ap_constyp_t constyp, const texpr0::builder& t, const scalar& modulo);

  tcons0(const tcons0& x);

  tcons0(const tcons0& x, const dimchange& d, bool add=true);

  tcons0(const tcons0& x, const dimperm& d);

  tcons0(unsat x);

  tcons0(const lincons0& x);



  /* destructor */
  /* ========== */


  ~tcons0();


  /* 'Intelligent' constructors */
  /* ========================== */


  friend tcons0 operator>=(const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator<=(const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator> (const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator< (const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator==(const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator!=(const texpr0::builder& a, const texpr0::builder& b);
  

  /* assignment */
  /* ========== */


  tcons0& operator= (const tcons0& x);

  tcons0& operator= (unsat x);

  tcons0& operator= (const lincons0& x);

  void set_modulo(const scalar& c);  

  void set_texpr(const texpr0::builder& c);



  /* dimension operations */
  /* ==================== */


  void add_dimensions(const dimchange& d);

  void remove_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);



  /* access */
  /* ====== */


  /* get */
 
  ap_constyp_t& get_constyp();
  
  const ap_constyp_t& get_constyp() const;

  bool has_modulo() const;

  bool has_texpr() const;

  scalar& get_modulo();
 
  const scalar& get_modulo() const;

  texpr0::iterator get_texpr();
 
  texpr0::const_iterator get_texpr() const;
 


  /* print */
  /* ===== */


  friend std::ostream& operator<< (std::ostream& os, const tcons0& s);

  void print(char** name_of_dim=NULL, FILE* stream=stdout) const;

 
  /* tests */
  /* ===== */


  bool is_interval_cst() const;

  bool is_interval_linear() const;

  bool is_interval_polynomial() const;

  bool is_interval_polyfrac() const;

  bool is_scalar() const;



  /* C-level compatibility */
  /* ===================== */


  const ap_tcons0_t* get_ap_tcons0_t() const;

  ap_tcons0_t* get_ap_tcons0_t();
 

};



/* ================================= */
/* tcons0_array                    */
/* ================================= */


class tcons0_array : public use_malloc {

protected:

  ap_tcons0_array_t a;  

  tcons0_array(ap_tcons0_array_t& a) : a(a) {}

  friend class abstract0;
  friend class tcons1_array;

public:
  
  /* constructors */
  /* ============ */


  tcons0_array(size_t size);

  tcons0_array(const tcons0_array& x);

  tcons0_array(const tcons0_array& x, const dimchange& d, bool add=true);

  tcons0_array(const tcons0_array& x, const dimperm& d);

  tcons0_array(size_t size, const tcons0 x[]);

  tcons0_array(const std::vector<tcons0>& x);

  tcons0_array(const lincons0_array& x);



  /* destructor */
  /* ========== */


  ~tcons0_array();



  /* assignment */
  /* ========== */


  tcons0_array& operator= (const tcons0_array& x);

  tcons0_array& operator= (const tcons0 x[]);

  tcons0_array& operator= (const std::vector<tcons0>& x);

  tcons0_array& operator= (const lincons0_array& x);



  /* dimension operations */
  /* ==================== */


  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  void remove_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);



  /* access */
  /* ====== */


  size_t size() const;

  tcons0* contents();

  const tcons0* contents() const;
  
  tcons0& operator[](size_t i);

  const tcons0& operator[](size_t i) const;

  tcons0& get(size_t i);

  const tcons0& get(size_t i) const;



  /* conversion */
  /* ========== */
  

  operator std::vector<tcons0>() const;



  /* print */
  /* ===== */


  
  friend std::ostream& operator<< (std::ostream& os, const tcons0_array& s);

  void print(char** name_of_dim = NULL, FILE* stream=stdout) const;



  /* tests */
  /* ===== */


  bool is_interval_linear() const;



  /* C-level compatibility */
  /* ===================== */


  const ap_tcons0_array_t* get_ap_tcons0_array_t() const;

  ap_tcons0_array_t* get_ap_tcons0_array_t();

};

#include "apxx_tcons0_inline.hh"

}

#endif /* __APXX_TCONS0_HH */