libpolybori-dev 0.8.3-3 / usr / include / polybori / BooleEnv.h

This file is indexed.

/usr/include/polybori/BooleEnv.h is in libpolybori-dev 0.8.3-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
// -*- c++ -*-
//*****************************************************************************
/** @file BooleEnv.h 
 *
 * @author Alexander Dreyer
 * @date 2006-03-06
 *
 * This file the class BooleEnv, where handles global (static) strucutres of
 * PolyBoRi. 
 *
 * @par Copyright:
 *   (c) 2007 by The PolyBoRi Team
**/
//*****************************************************************************

#ifndef polybori_BooleEnv_h_
#define polybori_BooleEnv_h_

// load PolyBoRi settings
# include <polybori/pbori_defs.h>

#include <polybori/BoolePolyRing.h>
#include <vector>

// Obey stricter dependence of Sun Studio compiler
// todo: resolve dependency 
#if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
# define PBORI_ENV_RING_NOTINLINED
#endif


BEGIN_NAMESPACE_PBORI


class BoolePolyRing;
//extern BoolePolyRing active_ring;
class COrderingBase;

/** @class BooleEnv
 * @brief This class is just a wrapper accessing global structures.
 *
 *
 **/


class BooleEnv: 
  public CTypes::orderenums_type, public CTypes::compenums_type, 
  public CTypes::auxtypes_type {

 public:
  //-------------------------------------------------------------------------
  // types definitions
  //-------------------------------------------------------------------------

  /// generic access to current type
  typedef BooleEnv self;

  /// generic access to base type
  typedef CTypes::orderenums_type base;

  /// @name adopt global type definitions
  //@{
  typedef CTypes::ordercode_type ordercode_type;
  typedef BoolePolyRing::dd_type dd_type;
  typedef BoolePolyRing::var_type var_type;
  typedef CTypes::vartext_type vartext_type;
  //@}

  /// Type for block indices
  typedef std::vector<idx_type> block_idx_type;

  /// Type for block iterators
  typedef block_idx_type::const_iterator block_iterator;

  //-------------------------------------------------------------------------
  // constructors and destructor
  //-------------------------------------------------------------------------

  /// Explicitely mention ordercodes' enumeration
  using base::ordercodes;

//   /// Access idx-th variable of the active ring
//   static var_type variable(idx_type idx);

//   /// Get numerical code for current ordering
//   static ordercode_type getOrderCode();

//   /// Get numerical code for current base ordering 
//   /// (the same for non-block orderings)
//   static ordercode_type getBaseOrderCode();

//   /// Get empty decision diagram
//   static dd_type zero();

//   /// Get decision diagram with all variables negated
//   static dd_type one();

//   /// Get number of ring variables the of active ring
//   static size_type nVariables();

  typedef BoolePolyRing ring_type;

  typedef COrderingBase order_type;

// private:
// #ifdef PBORI_ENV_RING_NOTINLINED
//   static ring_type& ring();
// #else
//   static ring_type& ring() {
//     static BooleEnv::ring_type active_ring(1000, CTypes::lp, false);

//     return active_ring;
//   }
// #endif
//   //  static manager_type& manager();
//   static order_type& ordering();
// public:

//   /// Set name of variable with index idx
//   static void setVariableName(idx_type idx, vartext_type varname);

//   /// Get name of variable with index idx
//   static vartext_type getVariableName(idx_type idx);

//   /// @name interface for block orderings, if the vcurrent orderins is a block ordering
//   //@{
//   /// Returns iterator over the indices, where the (next) block starts. 
//   /// (The first one implicitely starts at zero.)
//   static block_iterator blockBegin();

//   /// Returns end marker of iteration
//   static block_iterator blockEnd();

//   /// Add index where the next block starts
//   static void appendBlock(idx_type idx);

//   /// Reset block-related data
//   static void clearBlocks();

//   /// Index where the last blocks starts
//   static idx_type lastBlockStart();
//   //@}

//   /// Change order of current ring
//   static void changeOrdering(ordercode_type code);

//   /// Print low-level information
//   static ostream_type& print(ostream_type&);

//   /// Activate given ring
//   static void set(ring_type& theRing);
};

///please use BooleEnv::ring()


/// Extract block data without exposing ordering stuff
BooleEnv::block_iterator 
block_begin(const BooleEnv::ring_type& ring);


/// Extract block data without exposing ordering stuff
BooleEnv::block_iterator 
block_end(const BooleEnv::ring_type& ring);

END_NAMESPACE_PBORI

#endif // of #ifndef polybori_BooleEnv_h_

APT Browse - Built by Thomas Orozco.