00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef PPL_globals_defs_hh
00024 #define PPL_globals_defs_hh 1
00025
00026 #include "globals.types.hh"
00027 #include "C_Integer.hh"
00028 #include "meta_programming.hh"
00029 #include "Slow_Copy.hh"
00030 #include "Temp.defs.hh"
00031 #include <exception>
00032 #include <gmpxx.h>
00033
00034 namespace Parma_Polyhedra_Library {
00035
00037 dimension_type
00038 not_a_dimension();
00039
00040 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00041
00047 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00048 template <typename T>
00049 inline typename Enable_If<Slow_Copy<T>::value, void>::type
00050 swap(T&, T&) {
00051 COMPILE_TIME_CHECK(!Slow_Copy<T>::value, "missing swap specialization");
00052 }
00053
00054
00055 #define TEMP_INTEGER(id) DIRTY_TEMP0(Coefficient, id)
00056
00057 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00059
00076 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00077 dimension_type
00078 compute_capacity(dimension_type requested_size,
00079 dimension_type maximum_size);
00080
00081
00082 dimension_type
00083 compute_capacity(dimension_type requested_size);
00084
00086
00091 class Throwable {
00092 public:
00094 virtual void throw_me() const = 0;
00095
00097 virtual ~Throwable();
00098 };
00099
00123 extern const Throwable* volatile abandon_expensive_computations;
00124
00125 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00126
00132 #endif
00133 void
00134 maybe_abandon();
00135
00137
00140 struct From_Covering_Box {
00141 };
00142
00144
00148 struct Recycle_Input {
00149 };
00150
00151
00152 #define PPL_STR(s) #s
00153
00154 #define PPL_XSTR(s) PPL_STR(s)
00155
00156 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00157 #define PPL_OUTPUT_DECLARATIONS \
00158 \
00159 void ascii_dump() const; \
00160 \
00161 void ascii_dump(std::ostream& s) const; \
00162 \
00163 void print() const;
00164 #else
00165 #define PPL_OUTPUT_DECLARATIONS \
00166 void ascii_dump() const; \
00167 void ascii_dump(std::ostream& s) const; \
00168 void print() const;
00169 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00170
00171 #define PPL_OUTPUT_DEFINITIONS(class_name) \
00172 void \
00173 Parma_Polyhedra_Library::class_name::ascii_dump() const { \
00174 ascii_dump(std::cerr); \
00175 } \
00176 \
00177 void \
00178 Parma_Polyhedra_Library::class_name::print() const { \
00179 using namespace IO_Operators; \
00180 std::cerr << *this; \
00181 }
00182
00183 #define PPL_OUTPUT_DEFINITIONS_ASCII_ONLY(class_name) \
00184 void \
00185 Parma_Polyhedra_Library::class_name::ascii_dump() const { \
00186 ascii_dump(std::cerr); \
00187 } \
00188 \
00189 void \
00190 Parma_Polyhedra_Library::class_name::print() const { \
00191 std::cerr << "No user level output operator defined " \
00192 << "for class " PPL_XSTR(class_name) << "." << std::endl; \
00193 }
00194
00195 #define PPL_OUTPUT_TEMPLATE_DEFINITIONS(type_symbol, class_prefix) \
00196 template <typename type_symbol> \
00197 void \
00198 class_prefix::ascii_dump() const { \
00199 ascii_dump(std::cerr); \
00200 } \
00201 \
00202 template <typename type_symbol> \
00203 void \
00204 class_prefix::print() const { \
00205 using namespace IO_Operators; \
00206 std::cerr << *this; \
00207 }
00208
00209
00210
00211
00212
00213 #define PPL_OUTPUT_2_PARAM_TEMPLATE_DEFINITIONS(type_symbol1, \
00214 type_symbol2, \
00215 class_prefix) \
00216 template <typename type_symbol1, typename type_symbol2> \
00217 void \
00218 class_prefix<type_symbol1, type_symbol2>::ascii_dump() const { \
00219 ascii_dump(std::cerr); \
00220 } \
00221 \
00222 template <typename type_symbol1, typename type_symbol2> \
00223 void \
00224 class_prefix<type_symbol1, type_symbol2>::print() const { \
00225 using namespace IO_Operators; \
00226 std::cerr << *this; \
00227 }
00228
00229
00230 #define PPL_OUTPUT_3_PARAM_TEMPLATE_DEFINITIONS(type_symbol1, \
00231 type_symbol2, \
00232 type_symbol3, \
00233 class_prefix) \
00234 template <typename type_symbol1, typename type_symbol2, \
00235 typename type_symbol3> \
00236 void \
00237 class_prefix<type_symbol1, type_symbol2, type_symbol3>::ascii_dump() \
00238 const { \
00239 ascii_dump(std::cerr); \
00240 } \
00241 \
00242 template <typename type_symbol1, typename type_symbol2, \
00243 typename type_symbol3> \
00244 void \
00245 class_prefix<type_symbol1, type_symbol2, type_symbol3>::print() \
00246 const { \
00247 using namespace IO_Operators; \
00248 std::cerr << *this; \
00249 }
00250
00251 #define PPL_OUTPUT_TEMPLATE_DEFINITIONS_ASCII_ONLY(type_symbol, class_prefix) \
00252 template <typename type_symbol> \
00253 void \
00254 class_prefix::ascii_dump() const { \
00255 ascii_dump(std::cerr); \
00256 } \
00257 \
00258 template <typename type_symbol> \
00259 void \
00260 class_prefix::print() const { \
00261 std::cerr << "No user level output operator defined " \
00262 << "for " PPL_XSTR(class_prefix) << "." << std::endl; \
00263 }
00264
00265 template <typename T, long long v, typename Enable = void>
00266 struct Fit : public False {
00267 };
00268
00269 template <typename T, long long v>
00270 struct Fit<T, v, typename Enable_If<C_Integer<T>::value>::type> {
00271 enum {
00272 value = (v >= static_cast<long long>(C_Integer<T>::min)
00273 && v <= static_cast<long long>(C_Integer<T>::max))
00274 };
00275 };
00276
00277 template <typename T, long long v>
00278 struct TConstant {
00279 static const T value = v;
00280 };
00281
00282
00283 template <typename T, long long v>
00284 const T TConstant<T, v>::value;
00285
00286 template <typename T, long long v, bool prefer_signed = true,
00287 typename Enable = void>
00288 struct Constant_ : public TConstant<T, v> {
00289 };
00290
00291 template <typename T, long long v, bool prefer_signed>
00292 struct Constant_<T, v, prefer_signed,
00293 typename Enable_If<(Fit<typename C_Integer<T>::smaller_signed_type, v>::value
00294 && (prefer_signed ||
00295 !Fit<typename C_Integer<T>::smaller_unsigned_type, v>::value))>::type>
00296 : public Constant_<typename C_Integer<T>::smaller_signed_type, v, prefer_signed> {
00297 };
00298
00299 template <typename T, long long v, bool prefer_signed>
00300 struct Constant_<T, v, prefer_signed,
00301 typename Enable_If<(Fit<typename C_Integer<T>::smaller_unsigned_type, v>::value
00302 && (!prefer_signed ||
00303 !Fit<typename C_Integer<T>::smaller_signed_type, v>::value))>::type>
00304 : public Constant_<typename C_Integer<T>::smaller_unsigned_type, v, prefer_signed> {
00305 };
00306
00307 template <long long v, bool prefer_signed = true>
00308 struct Constant : public Constant_<long long, v, prefer_signed> {
00309 };
00310
00312
00313
00314 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00315
00319 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00320 template <typename T>
00321 typename Enable_If<Is_Native<T>::value, memory_size_type>::type
00322 total_memory_in_bytes(const T&);
00323
00324 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00325
00329 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00330 template <typename T>
00331 typename Enable_If<Is_Native<T>::value, memory_size_type>::type
00332 external_memory_in_bytes(const T&);
00333
00334 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00336 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00337 memory_size_type
00338 total_memory_in_bytes(const mpz_class& x);
00339
00340 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00342 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00343 memory_size_type
00344 external_memory_in_bytes(const mpz_class& x);
00345
00346 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00348 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00349 memory_size_type
00350 total_memory_in_bytes(const mpq_class& x);
00351
00352 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00354 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00355 memory_size_type
00356 external_memory_in_bytes(const mpq_class& x);
00357
00359
00360
00361 template <typename T, typename Enable = void>
00362 struct Has_OK : public False { };
00363
00364 template <typename T>
00365 struct Has_OK<T, typename Enable_If_Is<bool (T::*)() const, &T::OK>::type>
00366 : public True {
00367 };
00368
00369 template <typename T>
00370 inline typename Enable_If<Has_OK<T>::value, bool>::type
00371 f_OK(const T& to) {
00372 return to.OK();
00373 }
00374
00375 #define FOK(T) inline bool f_OK(const T&) { return true; }
00376
00377 FOK(char)
00378 FOK(signed char)
00379 FOK(unsigned char)
00380 FOK(signed short)
00381 FOK(unsigned short)
00382 FOK(signed int)
00383 FOK(unsigned int)
00384 FOK(signed long)
00385 FOK(unsigned long)
00386 FOK(signed long long)
00387 FOK(unsigned long long)
00388 FOK(float)
00389 FOK(double)
00390 FOK(long double)
00391 FOK(mpz_class)
00392 FOK(mpq_class)
00393
00394 }
00395
00396 #include "globals.inlines.hh"
00397
00398 #endif // !defined(PPL_globals_defs_hh)