/home/mine/apron/apronxx/apxx_environment.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_environment.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_ENVIRONMENT_HH
#define __APXX_ENVIRONMENT_HH
 
#include <string>
#include <vector>
 
#include "ap_environment.h"
#include "apxx_dimension.hh"
#include "apxx_var.hh"
 
 
namespace apron {
 
 
/* ================================= */
/* environment                       */
/* ================================= */


 * variable name addition, deletion, or renaming. Thus, such an operation can change the dimension associated to existing
 * variable names.
 *
 * Environments are reference-counted and the API is fully functional (i.e., functions do not change *this but return
 * a new object instead).
 */
class environment : public use_malloc {
 
protected:
 
  ap_environment_t* e;

  environment(ap_environment_t* x) : e(x) {}
 
  friend class linexpr1;
  friend class lincons1;
  friend class lincons1_array;
  friend class generator1;
  friend class generator1_array;
  friend class texpr1;
  friend class tcons1;
  friend class tcons1_array;
  friend class abstract1;
 
public:
 
 
  /* constructors */
  /* ============ */
 


  //! Creates a new empty environment.
  environment();

  environment(const std::vector<var>& intdim, const std::vector<var>& realdim);

  environment(const var* intdim, size_t intdim_size, const var* realdim, size_t realdim_size);

  environment(const environment& x);

 



  ~environment();

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

  /** @name Assignment */

  const environment& operator=(const environment& x);

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


  //@{

  environment add(const std::vector<var>& intdim, const std::vector<var>& realdim) const;

  environment add(const var* intdim, size_t intdim_size, const var* realdim, size_t realdim_size) const;

  /*! \brief Returns a copy of the environment with some integer and/or real variable names added.
   *
   * Sets perm to the dimension permutation that has been performed after appending variable names at the end of
   * integer (resp. real) dimensions to get them sorted again.
   *
   * \throw std::invalid_argument if the resulting environment has duplicate variable names.
   */
  environment add(const std::vector<var>& intdim, const std::vector<var>& realdim, dimperm& perm) const;

  /*! \brief Returns a copy of the environment with intdim_size integer and realdim_size real variable names added.
   *
   * Sets perm to the dimension permutation that has been performed after appending variable names at the end of
   * integer (resp. real) dimensions to get them sorted again.
   *
   * \throw std::invalid_argument if the resulting environment has duplicate variable names.
   */
  environment add(const var* intdim, size_t intdim_size, const var* realdim, size_t realdim_size, dimperm& perm) const;


   *
   * \throw std::invalid_argument if some variable name does not exist.
   */
  environment remove(const std::vector<var>& dims) const;

  environment remove(const var* dims, size_t dims_size) const;


   *
   * dims[i].first is replaced with dims[i].second.
   *
   * \throw std::invalid_argument if some variable name does not exist.
   */
  environment rename(const std::vector<std::pair<var,var> >& dims) const;


  environment rename(const var* before, const var* after, size_t dims_size) const;

  environment rename(const std::vector<std::pair<var,var> >& dims, dimperm& perm) const;


   * before[i] is replaced with after[i]. Both array should contain dims_size elements.
   * Sets perm to the dimension permutation that has been performed after renaming the variable names in-place to get them 
   * sorted again.
   *
   * \throw std::invalid_argument if some variable name does not exist.
   */
  environment rename(const var* before, const var* after, size_t dims_size, dimperm& perm) const;

  friend environment lce(const environment& x, const environment& y);

   *
   * Sets chgx (resp. chgy) to the dimension transformation that has been performed after appending the required 
   * variable names to x (resp. y) to keep them sorted.
   *
   * \throw std::invalid_argument if some variable name has different type in both environments
   */
  friend environment lce(const environment& x, const environment& y, dimchange& chgx, dimchange& chgy);


   * \throw std::invalid_argument if some variable name has different type in different environments
   */
  friend environment lce(const std::vector<environment>& x);

  friend environment lce(const environment* env, size_t env_size);


   * chg must have space for at least env_size elements.
   *
   * \throw std::invalid_argument if some variable name has different type in different environments
   */
  friend environment lce(const std::vector<environment>& x, std::vector<dimchange>& chg);

  friend environment lce(const environment* env, dimchange* chg, size_t env_size);


   *
   * \throw std::invalid_argument if x is not a subset of y, or if x and chg have different size.
   */
  friend dimchange get_dimchange(const environment& x, const environment& y);

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



  size_t intdim() const;

  size_t realdim() const;

  bool contains(const var& x) const;

  ap_dim_t operator[] (const var& x) const;

  const var& operator[] (ap_dim_t d) const;

  ap_dim_t get_dim(const var& x) const;


   *
   * \throw std::out_of_range if the dimension is larger than the environment size.
   */
  const var& get_var(ap_dim_t d) const;

  std::vector<var> get_vars() const;
 

 
 
  /* Tests */
  /* ===== */


  friend bool operator==(const environment& x, const environment& y);

  //! Disequality testing.
  friend bool operator!=(const environment& x, const environment& y);

  friend bool operator<=(const environment& x, const environment& y);

  friend bool operator>=(const environment& x, const environment& y);


   *  -  0 if x equals y
   *  - +1 if x is a super-environment of y
   *  - +2 if x and y a not comparable but there exists a lowest upper bound
   */
  friend int cmp(const environment& x, const environment& y);

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


   //! Printing.
  friend std::ostream& operator<< (std::ostream& os, const environment& s); 

  void print(FILE* stream=stdout) const; 


 
 
  /* C API compatibility */
  /* =================== */

  /** @name C API compatibility */

  const ap_environment_t* get_ap_environment_t() const;


  ap_environment_t* get_ap_environment_t();

 
};
 
#include "apxx_environment_inline.hh"
 
}
 
#endif /* __APXX_ENVIRONMENT_HH */