/home/mine/apron/apronxx/apxx_generator0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_generator0.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_GENERATOR0_HH
#define __APXX_GENERATOR0_HH
 
#include <vector>
#include "ap_generator0.h"
#include "apxx_linexpr0.hh"
 
 
namespace apron {
 
 
 
/* ================================= */
/* generator0                        */
/* ================================= */
 


 *
 * A generator0 object represents a generator: vertex, ray, line, modular line, or modular ray.
 * It stores and manages a linexpr0 (linear expression with scalar coefficients only), 
 * and a generator type (vertex, ray , etc).
 */
class generator0 : public use_malloc {
 
protected:
  
  ap_generator0_t l; 

  generator0(ap_generator0_t& l) : l(l) {}
 
  friend class abstract0;
 
public:
 
 
  /* constructors */
  /* ============ */


  generator0(ap_gentyp_t gentyp=AP_GEN_RAY);

   *
   * \arg \c gentyp can be \c AP_GEN_LINE, \c AP_GEN_RAY, \c AP_GEN_VERTEX,  \c AP_GEN_LINEMOD,
   * or \c AP_GEN_RAYMOD.
   *
   * \warning \c lin should have only scalar (non-interval) coefficients (unchecked).
   */
  generator0(ap_gentyp_t gentyp, const linexpr0& lin);

  generator0(const generator0& x);

  generator0(const generator0& x, const dimchange& d);

  generator0(const generator0& x, const dimperm& d);
 
 
  /* destructor */
  /* ========== */

  ~generator0();
 
 
  /* assignment */
  /* ========== */

  //! (Deep) copy.
  generator0& operator= (const generator0& x);
 
 
  /* dimension operations */
  /* ==================== */

  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);
  
 
  /* access */
  /* ====== */
 
  /* size */


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

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

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

   * \note The only way the linear expression may be invalid is when accessing fields of uninitialised 
   * (or enlarged) generator0_array.
   */
  bool has_linexpr() const;


  linexpr0& get_linexpr();
 
  const linexpr0& get_linexpr() const;

  void set_linexpr(const linexpr0& c);
 
 
  /* print */
  /* ===== */


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

  void print(char** name_of_dim=NULL, FILE* stream=stdout) const;
 
 
  /* TODO: intelligent constructors */
 
 
  /* C-level compatibility */
  /* ===================== */

  const ap_generator0_t* get_ap_generator0_t() const;

  ap_generator0_t* get_ap_generator0_t();
 
};
 
 
 
 
/* ================================= */
/* generator0_array                  */
/* ================================= */
 


class generator0_array : public use_malloc {
 
protected:
 
  ap_generator0_array_t a;  


  generator0_array(ap_generator0_array_t& a) : a(a) {}
 
  friend class abstract0;
  friend class generator1_array;
 
public:
  
  /* constructors */
  /* ============ */


  /*! \brief Creates a new array of the given size containing uninitialized generators.
   *
   * has_linexpr will return false on all elements of the array.
   */
  generator0_array(size_t size);

  generator0_array(const generator0_array& x);

  generator0_array(const generator0_array& x, const dimchange& d);

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

  generator0_array(size_t size, const generator0 x[]);

  generator0_array(const std::vector<generator0>& x);

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



  ~generator0_array();

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

  /** @name Assignments */

  generator0_array& operator= (const generator0_array& x);


  generator0_array& operator= (const generator0 x[]);

  generator0_array& operator= (const std::vector<generator0>& x);

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


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

  void add_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);

  //@}
 
 
  /* access */
  /* ====== */



  size_t size() const;
 
  generator0* contents();

  //! Returns a pointer to the start of the internal array holding the generators.
  const generator0* contents() const;

  generator0& operator[](size_t i);

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


   *
   * \throw std::out_of_range if the index is invalid.
   */
  generator0& get(size_t i);


   *
   * \throw std::out_of_range if the index is invalid.
   */
  const generator0& get(size_t i) const;


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

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

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

  /** @name Printing */


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

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

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


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

  ap_generator0_array_t* get_ap_generator0_array_t();

};
 
 
#include "apxx_generator0_inline.hh"
 
}
 
#endif /* __APXX_GENERATOR0_HH */