Skip to content
This repository
Browse code

Some more work on what is public

  • Loading branch information...
commit d9985be3d8c771cfa24925efa24074571b9d1a99 1 parent cd420f3
Jakob Truelsen antialize authored
22 tpie/execution_time_predictor.h
@@ -63,23 +63,23 @@ class TPIE_PUBLIC unique_id_type {
63 63 };
64 64
65 65
66   -class TPIE_PUBLIC execution_time_predictor {
  66 +class TPIE_PUBLIC execution_time_predictor {
67 67 public:
68   - TPIE_PUBLIC execution_time_predictor(const std::string & id=std::string());
69   - TPIE_PUBLIC ~execution_time_predictor();
  68 + execution_time_predictor(const std::string & id=std::string());
  69 + ~execution_time_predictor();
70 70 ///////////////////////////////////////////////////////////////////////////
71 71 /// Estimate execution time.
72 72 /// \param n Input size
73 73 /// \param confidence (output) Confidence (between 0.0 and 1.0)
74 74 ///////////////////////////////////////////////////////////////////////////
75   - TPIE_PUBLIC time_type estimate_execution_time(stream_size_type n, double & confidence);
76   - TPIE_PUBLIC void start_execution(stream_size_type n);
77   - TPIE_PUBLIC time_type end_execution();
78   - TPIE_PUBLIC std::string estimate_remaining_time(double progress);
79   -
80   - TPIE_PUBLIC static void start_pause();
81   - TPIE_PUBLIC static void end_pause();
82   - TPIE_PUBLIC static void disable_time_storing();
  75 + time_type estimate_execution_time(stream_size_type n, double & confidence);
  76 + void start_execution(stream_size_type n);
  77 + time_type end_execution();
  78 + std::string estimate_remaining_time(double progress);
  79 +
  80 + static void start_pause();
  81 + static void end_pause();
  82 + static void disable_time_storing();
83 83
84 84 //Used by fractional_time_perdictor
85 85 //TPIE_OS_OFFSET m_aux1;
26 tpie/fractional_progress.h
@@ -55,9 +55,9 @@ class fractional_progress;
55 55 ///////////////////////////////////////////////////////////////////////////////
56 56 class TPIE_PUBLIC fractional_subindicator: public progress_indicator_subindicator {
57 57 public:
58   - TPIE_PUBLIC fractional_subindicator(fractional_progress & fp);
  58 + fractional_subindicator(fractional_progress & fp);
59 59
60   - TPIE_PUBLIC fractional_subindicator(fractional_progress & fp,
  60 + fractional_subindicator(fractional_progress & fp,
61 61 const char * id,
62 62 const char * file,
63 63 const char * function,
@@ -66,7 +66,7 @@ class TPIE_PUBLIC fractional_subindicator: public progress_indicator_subindicato
66 66 description_importance importance=IMPORTANCE_MAJOR,
67 67 bool enabled=true);
68 68
69   - TPIE_PUBLIC void setup(const char * id,
  69 + void setup(const char * id,
70 70 const char * file,
71 71 const char * function,
72 72 stream_size_type n,
@@ -74,17 +74,17 @@ class TPIE_PUBLIC fractional_subindicator: public progress_indicator_subindicato
74 74 description_importance importance=IMPORTANCE_MAJOR,
75 75 bool enabled=true);
76 76
77   - TPIE_PUBLIC ~fractional_subindicator();
  77 + ~fractional_subindicator();
78 78
79 79 ///////////////////////////////////////////////////////////////////////////
80 80 /// \copydoc progress_indicator_subindicator::init
81 81 ///////////////////////////////////////////////////////////////////////////
82   - TPIE_PUBLIC virtual void init(stream_size_type range);
  82 + virtual void init(stream_size_type range);
83 83
84 84 ///////////////////////////////////////////////////////////////////////////
85 85 /// \copydoc progress_indicator_subindicator::done
86 86 ///////////////////////////////////////////////////////////////////////////
87   - TPIE_PUBLIC virtual void done();
  87 + virtual void done();
88 88 private:
89 89 #ifndef TPIE_NDEBUG
90 90 bool m_init_called;
@@ -106,29 +106,29 @@ class TPIE_PUBLIC fractional_subindicator: public progress_indicator_subindicato
106 106 ///////////////////////////////////////////////////////////////////////////////
107 107 class TPIE_PUBLIC fractional_progress {
108 108 public:
109   - TPIE_PUBLIC fractional_progress(progress_indicator_base * pi);
110   - TPIE_PUBLIC ~fractional_progress();
  109 + fractional_progress(progress_indicator_base * pi);
  110 + ~fractional_progress();
111 111
112 112 ///////////////////////////////////////////////////////////////////////////
113 113 /// \copydoc progress_indicator_base::done
114 114 ///////////////////////////////////////////////////////////////////////////
115   - TPIE_PUBLIC void done();
  115 + void done();
116 116
117 117 ///////////////////////////////////////////////////////////////////////////
118 118 /// \copydoc progress_indicator_base::init
119 119 ///////////////////////////////////////////////////////////////////////////
120   - TPIE_PUBLIC void init(stream_size_type range=0);
  120 + void init(stream_size_type range=0);
121 121
122 122 ///////////////////////////////////////////////////////////////////////////
123 123 /// \brief Return this progress indicator's unique id.
124 124 ///////////////////////////////////////////////////////////////////////////
125   - TPIE_PUBLIC unique_id_type & id();
  125 + unique_id_type & id();
126 126
127   - TPIE_PUBLIC void push_breadcrumb(const char * crumb, description_importance importance) {
  127 + void push_breadcrumb(const char * crumb, description_importance importance) {
128 128 if (m_pi) m_pi->push_breadcrumb(crumb, importance);
129 129 }
130 130
131   - TPIE_PUBLIC void pop_breadcrumb() {
  131 + void pop_breadcrumb() {
132 132 if (m_pi) m_pi->pop_breadcrumb();
133 133 }
134 134
18 tpie/memory.h
@@ -47,8 +47,8 @@ namespace bits {
47 47 ///////////////////////////////////////////////////////////////////////////////
48 48 struct TPIE_PUBLIC out_of_memory_error : public std::bad_alloc {
49 49 const char * msg;
50   - TPIE_PUBLIC out_of_memory_error(const char * s) : msg(s) { }
51   - TPIE_PUBLIC virtual const char* what() const throw() {return msg;}
  50 + out_of_memory_error(const char * s) : msg(s) { }
  51 + virtual const char* what() const throw() {return msg;}
52 52 };
53 53
54 54
@@ -76,12 +76,12 @@ class TPIE_PUBLIC memory_manager {
76 76 ///////////////////////////////////////////////////////////////////////////
77 77 /// Return the current amount of memory used.
78 78 ///////////////////////////////////////////////////////////////////////////
79   - TPIE_PUBLIC size_t used() const throw();
  79 + size_t used() const throw();
80 80
81 81 ///////////////////////////////////////////////////////////////////////////
82 82 /// Return the amount of memory still available to allocation.
83 83 ///////////////////////////////////////////////////////////////////////////
84   - TPIE_PUBLIC size_t available() const throw();
  84 + size_t available() const throw();
85 85
86 86 ///////////////////////////////////////////////////////////////////////////
87 87 /// Return the memory limit.
@@ -94,13 +94,13 @@ class TPIE_PUBLIC memory_manager {
94 94 /// no exception will be thrown.
95 95 /// \param new_limit The new memory limit in bytes.
96 96 ///////////////////////////////////////////////////////////////////////////
97   - TPIE_PUBLIC void set_limit(size_t new_limit);
  97 + void set_limit(size_t new_limit);
98 98
99 99 ///////////////////////////////////////////////////////////////////////////
100 100 /// \brief Set the memory limit enforcement policy.
101 101 /// \param e The new enforcement policy.
102 102 ///////////////////////////////////////////////////////////////////////////
103   - TPIE_PUBLIC void set_enforcement(enforce_t e);
  103 + void set_enforcement(enforce_t e);
104 104
105 105 ///////////////////////////////////////////////////////////////////////////
106 106 /// \brief Return the current memory limit enforcement policy.
@@ -113,19 +113,19 @@ class TPIE_PUBLIC memory_manager {
113 113 /// Possibly throws a warning or an exception if the memory limit is
114 114 /// exceeded, depending on the enforcement.
115 115 ///////////////////////////////////////////////////////////////////////////
116   - TPIE_PUBLIC void register_allocation(size_t bytes);
  116 + void register_allocation(size_t bytes);
117 117
118 118 ///////////////////////////////////////////////////////////////////////////
119 119 /// \internal
120 120 /// Register that some memory has been freed.
121 121 ///////////////////////////////////////////////////////////////////////////
122   - TPIE_PUBLIC void register_deallocation(size_t bytes);
  122 + void register_deallocation(size_t bytes);
123 123
124 124 ///////////////////////////////////////////////////////////////////////////
125 125 /// \internal
126 126 /// Construct the memory manager object.
127 127 ///////////////////////////////////////////////////////////////////////////
128   - TPIE_PUBLIC memory_manager();
  128 + memory_manager();
129 129
130 130 ///////////////////////////////////////////////////////////////////////////
131 131 /// \internal
6 tpie/progress_indicator_base.h
@@ -205,10 +205,10 @@ class TPIE_PUBLIC progress_indicator_base {
205 205 ///////////////////////////////////////////////////////////////////////////
206 206 /// Makes sure m_threshold has been set.
207 207 ///////////////////////////////////////////////////////////////////////////
208   - TPIE_PUBLIC static void compute_threshold();
  208 + static void compute_threshold();
209 209
210   - TPIE_PUBLIC progress_indicator_base();
211   - TPIE_PUBLIC progress_indicator_base(const progress_indicator_base& other);
  210 + progress_indicator_base();
  211 + progress_indicator_base(const progress_indicator_base& other);
212 212 };
213 213
214 214 } // tpie namespace

0 comments on commit d9985be

Please sign in to comment.
Something went wrong with that request. Please try again.