src/integer/ring/cl_0_ring.cc

   1 // Null ring.
   2
   3 // General includes.
   4 #include "base/cl_sysdep.h"
   5
   6
   7 // Specification.
   8 #include "cln/null_ring.h"
   9
  10
  11 // Implementation.
  12
  13 #include "cln/integer_class.h"
  14
  15 namespace cln {
  16
  17 static const _cl_ring_element null_op0 (cl_heap_ring* R)
  18 {
  19         return _cl_ring_element(R, (cl_I)0);
  20 }
  21
  22 static const _cl_ring_element null_op1 (cl_heap_ring* R, const _cl_ring_element& x)
  23 {
  24         cl_unused x;
  25         return _cl_ring_element(R, (cl_I)0);
  26 }
  27
  28 static const _cl_ring_element null_op2 (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
  29 {
  30         cl_unused x;
  31         cl_unused y;
  32         return _cl_ring_element(R, (cl_I)0);
  33 }
  34
  35 static void null_fprint (cl_heap_ring* R, std::ostream& stream, const _cl_ring_element& x)
  36 {
  37         cl_unused R;
  38         cl_unused x;
  39         fprint(stream,"0");
  40 }
  41
  42 static bool null_equal (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
  43 {
  44         cl_unused R;
  45         cl_unused x;
  46         cl_unused y;
  47         return true;
  48 }
  49
  50 #define null_zero null_op0
  51 static bool null_zerop (cl_heap_ring* R, const _cl_ring_element& x)
  52 {
  53         cl_unused R;
  54         cl_unused x;
  55         return true;
  56 }
  57 #define null_plus null_op2
  58 #define null_minus null_op2
  59 #define null_uminus null_op1
  60
  61 #define null_one null_op0
  62 static const _cl_ring_element null_canonhom (cl_heap_ring* R, const cl_I& x)
  63 {
  64         cl_unused x;
  65         return _cl_ring_element(R, (cl_I)0);
  66 }
  67 #define null_mul null_op2
  68 #define null_square null_op1
  69 static const _cl_ring_element null_expt_pos (cl_heap_ring* R, const _cl_ring_element& x, const cl_I& y)
  70 {
  71         cl_unused x;
  72         cl_unused y;
  73         return _cl_ring_element(R, (cl_I)0);
  74 }
  75
  76 static cl_ring_setops& null_setops()
  77 {
  78         static cl_ring_setops ops = {
  79                 null_fprint,
  80                 null_equal
  81         };
  82         return ops;
  83 }
  84
  85 static cl_ring_addops& null_addops()
  86 {
  87         static cl_ring_addops ops = {
  88                 null_zero,
  89                 null_zerop,
  90                 null_plus,
  91                 null_minus,
  92                 null_uminus
  93         };
  94         return ops;
  95 }
  96
  97 static cl_ring_mulops& null_mulops()
  98 {
  99         static cl_ring_mulops ops = {
 100                  null_one,
 101                  null_canonhom,
 102                  null_mul,
 103                  null_square,
 104                  null_expt_pos
 105         };
 106         return ops;
 107 }
 108
 109 static const cl_class& cl_class_null_ring();
 110
 111 class cl_heap_null_ring : public cl_heap_ring {
 112         SUBCLASS_cl_heap_ring()
 113 public:
 114         // Constructor.
 115         cl_heap_null_ring ()
 116                 : cl_heap_ring (&null_setops(),&null_addops(),&null_mulops())
 117                 { type = &cl_class_null_ring(); }
 118         // Destructor.
 119         ~cl_heap_null_ring () {}
 120 };
 121
 122 static void cl_null_ring_destructor (cl_heap* pointer)
 123 {
 124         (*(cl_heap_null_ring*)pointer).~cl_heap_null_ring();
 125 }
 126
 127 static void cl_null_ring_dprint (cl_heap* pointer)
 128 {
 129         cl_unused pointer;
 130         fprint(cl_debugout, "(cl_null_ring) cl_0_ring");
 131 }
 132
 133 static const cl_class& cl_class_null_ring()
 134 {
 135         static const cl_class cl_class_null_ring_instance = {
 136                  cl_null_ring_destructor,
 137                  cl_class_flags_number_ring,
 138                  cl_null_ring_dprint
 139         };
 140         return cl_class_null_ring_instance;
 141 }
 142
 143 cl_heap_null_ring* cl_heap_null_ring_instance;
 144 const cl_null_ring cl_0_ring = cl_0_ring;
 145
 146 inline cl_null_ring::cl_null_ring ()
 147         : cl_ring(cl_heap_null_ring_instance) {}
 148
 149 int cl_0_ring_init_helper::count = 0;
 150
 151 cl_0_ring_init_helper::cl_0_ring_init_helper()
 152 {
 153         if (count++ == 0) {
 154                 cl_heap_null_ring_instance = new cl_heap_null_ring();
 155                 new ((void *)&cl_0_ring) cl_null_ring();
 156          }
 157 }
 158
 159 cl_0_ring_init_helper::~cl_0_ring_init_helper()
 160 {
 161         if (--count == 0) {
 162                  delete cl_heap_null_ring_instance;
 163         }
 164 }
 165
 166 }  // namespace cln
 167