-
Notifications
You must be signed in to change notification settings - Fork 1
/
CLBigNum.cpp
161 lines (116 loc) · 2.72 KB
/
CLBigNum.cpp
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
// CLBigNum.cpp - Part of Helix
// Copyright (c) 2002 by Tom Weatherhead. All rights reserved.
// Started December 21, 2002
// This file contains an implementation of a limited-size big number class.
// This allows the buffer to be allocated as an array when the object is created,
// so that the buffer is contiguous and doesn't need to grow.
// The CLBigNumFactory class allows CLBigNum objects to be reused,
// instead of unnecessarily created and destroyed.
// The CLBigNum class currently requires a little-endian architecture.
#include <stack>
#include "Common.h"
using std::stack;
static const int knNumSegments = 1000;
class CLBigNumFactory;
class CLBigNum // Limited-size big number.
{
private:
typedef unsigned long SegmentType;
CLBigNumFactory & m_Factory;
SegmentType m_a[knNumSegments];
int m_nSize; // Number of segments in use.
public:
CLBigNum( CLBigNumFactory & factory );
CLBigNumFactory & GetFactory( void ); // Const or not const?
void Reset( void );
// Insert other members here.
}; // class CLBigNum
CLBigNum::CLBigNum( CLBigNumFactory & factory )
: m_Factory( factory )
{
Reset();
}
CLBigNumFactory & CLBigNum::GetFactory( void )
{
return( m_Factory );
}
void CLBigNum::Reset( void )
{
memset( m_a, 0, knNumSegments * sizeof( SegmentType ) );
m_nSize = 0;
}
class CLBigNumFactory
{
private:
stack<CLBigNum *> m_stack;
public:
CLBigNumFactory( void );
~CLBigNumFactory( void ); // Not virtual, so not part of a class heirarchy.
CLBigNum * Acquire( void );
void Release( CLBigNum * p );
}; // class CLBigNumFactory
CLBigNumFactory::CLBigNumFactory( void )
{
}
CLBigNumFactory::~CLBigNumFactory( void )
{
while( !m_stack.empty() )
{
CLBigNum * p = m_stack.top();
m_stack.pop();
delete p;
}
}
CLBigNum * CLBigNumFactory::Acquire( void )
{
CLBigNum * p = 0;
if( !m_stack.empty() )
{
p = m_stack.top();
m_stack.pop();
p->Reset();
}
else
{
try
{
p = new CLBigNum( *this );
}
catch( ... )
{
}
if( p == 0 )
{
ThrowHelixException( "Failed to create a CLBigNum object." );
}
}
return( p );
}
void CLBigNumFactory::Release( CLBigNum * p )
{
m_stack.push( p );
}
class CLBigNumPtr
{
private:
CLBigNum * m_ptr;
public:
CLBigNumPtr( CLBigNumFactory & factory )
: m_ptr( factory.Acquire() )
{
}
~CLBigNumPtr( void ) // Not virtual, so not part of a class heirarchy.
{
m_ptr->GetFactory().Release( m_ptr );
m_ptr = 0;
}
inline CLBigNum & operator*( void )
{
return( *m_ptr );
}
inline CLBigNum * operator->( void )
{
return( m_ptr );
}
}; // class CLBigNumPtr
// **** End of File ****