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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Array.h
//
// = AUTHOR
// Doug Schmidt
//
// ============================================================================
#if !defined (ACE_ARRAY_H)
#define ACE_ARRAY_H
#include "ace/ACE.h"
template <class T>
class ACE_Array
{
public:
// Define a "trait"
typedef T TYPE;
// = Exceptions.
// = Initialization and termination methods.
ACE_Array (size_t size);
// Dynamically create an uninitialized array.
ACE_Array (size_t size, const T &default_value);
// Dynamically initialize the entire array to the <default_value>.
ACE_Array (const ACE_Array<T> &s);
// The copy constructor performs initialization by making an exact
// copy of the contents of parameter <s>, i.e., *this == s will
// return true.
void operator= (const ACE_Array<T> &s);
// Assignment operator performs an assignment by making an exact
// copy of the contents of parameter <s>, i.e., *this == s will
// return true. Note that if the <max_size_> of <array_> is >= than
// <s.max_size_> we can copy it without reallocating. However, if
// <max_size_> is < <s.max_size_> we must delete the <array_>,
// reallocate a new <array_>, and then copy the contents of <s>.
~ACE_Array (void);
// Clean up the array (e.g., delete dynamically allocated memory).
// = Set/get methods.
T &operator [] (size_t index);
// Set item in the array at location <index>. Doesn't
// perform range checking.
const T &operator [] (size_t index) const;
// Get item in the array at location <index>. Doesn't
// perform range checking.
int set (const T &new_item, size_t index);
// Set an item in the array at location <index>. Returns
// -1 if <index> is not in range, else returns 0.
int get (T &item, size_t index) const;
// Get an item in the array at location <index>. Returns -1 if
// <index> is not in range, else returns 0. Note that this function
// copies the item. If you want to avoid the copy, you can use
// the const operator [], but then you'll be responsible for range checking.
size_t size (void) const;
// Returns the <cur_size_> of the array.
int operator== (const ACE_Array<T> &s) const;
// Compare this array with <s> for equality. Two arrays are equal
// if their size()'s are equal and all the elements from 0 .. size()
// are equal.
int operator!= (const ACE_Array<T> &s) const;
// Compare this array with <s> for inequality such that <*this> !=
// <s> is always the complement of the boolean return value of
// <*this> == <s>.
private:
int in_range (size_t index) const;
// Returns 1 if <index> is within range, i.e., 0 >= <index> <
// <cur_size_>, else returns 0.
size_t max_size_;
// Maximum size of the array, i.e., the total number of <T> elements
// in <array_>.
size_t cur_size_;
// Current size of the array. This starts out being == to
// <max_size_>. However, if we are assigned a smaller array, then
// <cur_size_> will become less than <max_size_>. The purpose of
// keeping track of both sizes is to avoid reallocating memory if we
// don't have to.
T *array_;
// Pointer to the array's storage buffer.
};
#if defined (__ACE_INLINE__)
#include "ace/Array.i"
#endif /* __ACE_INLINE__ */
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "ace/Array.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Array.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#endif /* ACE_ARRAY_H */
|
