/home/mine/apron/apronxx/apxx_generator1.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_generator1.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_GENERATOR1_HH
#define __APXX_GENERATOR1_HH
 
#include "ap_generator1.h"
#include "apxx_environment.hh"
#include "apxx_generator0.hh"
#include "apxx_linexpr1.hh"
 
namespace apron {
 
 
 
/* ================================= */
/* generator1                        */
/* ================================= */
 


 * reference count).
 */
class generator1 : public use_malloc {
 
protected:
  
  ap_generator1_t l; 

  generator1(ap_generator1_t p);
 
  friend class generator1_array;
 
public:
 
 
  /* constructors */
  /* ============ */


  generator1(const environment& e, const generator0& x);


   */
  generator1(const environment& e, ap_gentyp_t gentyp=AP_GEN_RAY);


   * \warning \c lin should have only scalar (non-interval) coefficients (unchecked).
   */
  generator1(ap_gentyp_t gentyp, const linexpr1& lin);

  generator1(const generator1& x);


   *
   * \throw std::invalid_argument if e is not a super-environment of that of x.
   */
  generator1(const generator1& x, const environment& e);

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

  
  ~generator1();


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



  generator1& operator= (const generator1& x);


   * it is created.
   *
   * \warning \c c should have only scalar (non-interval) coefficients (unchecked).
   * \warning assumes that c and *this have equal environments (unchecked).
   */
  void set_linexpr(const linexpr1& c);

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




  void extend_environment(const environment& e);

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


  environment get_environment() const;

  const generator0& get_generator0() const;

  generator0& get_generator0();

  /*! \brief Returns the size of the underlying linear expression.
   *
   * \throw std::invalid_argument if no valid linear expression has been defined.
   */
  size_t size() const;
 
 
  /* get */
  
  ap_gentyp_t& get_gentyp();
  

   *
   * \return either AP_GEN_LINE, AP_GEN_RAY, AP_GEN_VERTEX, AP_GEN_LINEMOD, or AP_GEN_RAYMOD.
   */
  const ap_gentyp_t& get_gentyp() const;
  

  bool has_linexpr() const;

   * \throw std::invalid_argument if no valid linear expression has been defined.
   */
  linexpr1 get_linexpr() const;

  coeff& get_cst();

  const coeff& get_cst() const;


  coeff& operator[](const var& v);
  
   *
   * \throw std::invalid_argument if the variable name is not present in the environment.
   * \throw std::invalid_argument if no valid linear expression has been defined.
   */
  const coeff& operator[](const var& v) const;

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


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

  void print(FILE* stream=stdout) const;

 
 
  /* TODO: intelligent constructors */
 
 
  /* C-level compatibility */
  /* ===================== */


  //! Returns a pointer to the internal APRON object stored in *this.
  const ap_generator1_t* get_ap_generator1_t() const;

  ap_generator1_t* get_ap_generator1_t();

};
 
 
 
/* ================================= */
/* generator1_array                  */
/* ================================= */
 


 */
class generator1_array : public use_malloc {
 
protected:
 
  ap_generator1_array_t a;  

  generator1_array(ap_generator1_array_t& a);
 
  friend class abstract1;
 
public:
  
  /* constructors */
  /* ============ */



  generator1_array(const environment& e, const generator0_array& x);


  generator1_array(const environment& e, size_t size);

  //! (Deep) copy.
  generator1_array(const generator1_array& x);

  generator1_array(const generator1_array& x, const environment& e);


   * \throw std::invalid_argument if size<1.
   */
  generator1_array(size_t size, const generator1 x[]);

  generator1_array(const std::vector<generator1>& x);

  //@}
 
 
  /* destructor */
  /* ========== */


  ~generator1_array();

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

  //@{

  generator1_array& operator= (const generator1_array& x);

  /*! \brief Copies the generators from the array into *this.
   *
   * \warning assumes that all generators have the same environment (unchecked).
   * \arg x should contain (at least) size elements.
   */
  generator1_array& operator= (const generator1 x[]);


  generator1_array& operator= (const std::vector<generator1>& x);

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


  //! Resizes the array.
  void resize(size_t size);


   * \throw std::invalid_argument if e is not a super-environment of that of *this.
   */
  void extend_environment(const environment& e);


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



  size_t size() const;

  environment get_environment() const;


  const generator0_array& get_generator0_array() const;

  generator0_array& get_generator0_array();

  generator1 get(size_t i) const;


  void set(size_t i, const generator1& x);

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

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

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



   */
  friend std::ostream& operator<< (std::ostream& os, const generator1_array& s);

  void print(FILE* stream=stdout) const;

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


  const ap_generator1_array_t* get_ap_generator1_array_t() const;

  ap_generator1_array_t* get_ap_generator1_array_t();

 
};
 
#include "apxx_generator1_inline.hh"
 
}
 
#endif /* __APXX_GENERATOR1_HH */