From ecd64d324450022be117ae8667b71adf0d602721 Mon Sep 17 00:00:00 2001 From: tosh Date: Wed, 27 Mar 2013 11:49:43 +0100 Subject: [PATCH] improves naming consistency (mostly member variable prefixes) --- interface/src/Stars.cpp | 52 ++++++++++++++++++++-------------------- shared/src/UrlReader.cpp | 10 ++++---- shared/src/UrlReader.h | 30 +++++++++++------------ 3 files changed, 46 insertions(+), 46 deletions(-) diff --git a/interface/src/Stars.cpp b/interface/src/Stars.cpp index ad4d3876fd..468b92e32b 100644 --- a/interface/src/Stars.cpp +++ b/interface/src/Stars.cpp @@ -310,7 +310,7 @@ namespace class Loader : UrlReader { - InputVertices* arr_vertex; + InputVertices& ref_vertices; unsigned val_limit; unsigned val_lineno; @@ -323,7 +323,7 @@ namespace bool loadVertices( InputVertices& destination, char const* url, unsigned limit) { - arr_vertex = & destination; + ref_vertices = destination; val_limit = limit; str_actual_url = url; // in case we fail early @@ -347,8 +347,8 @@ namespace val_lineno = 0u; str_actual_url = url; // new value in http redirect - arr_vertex->clear(); - arr_vertex->reserve(val_limit); + ref_vertices.clear(); + ref_vertices.reserve(val_limit); } size_t transfer(char* input, size_t bytes) @@ -383,35 +383,35 @@ namespace if (val_records_read++ == val_limit) { std::make_heap( - arr_vertex->begin(), arr_vertex->end(), + ref_vertices.begin(), ref_vertices.end(), GreaterBrightness() ); val_min_brightness = getBrightness( - arr_vertex->begin()->getColor() ); + ref_vertices.begin()->getColor() ); } - if (arr_vertex->size() == val_limit) + if (ref_vertices.size() == val_limit) { if (val_min_brightness >= getBrightness(c)) continue; std::pop_heap( - arr_vertex->begin(), arr_vertex->end(), + ref_vertices.begin(), ref_vertices.end(), GreaterBrightness() ); - arr_vertex->pop_back(); + ref_vertices.pop_back(); } } - arr_vertex->push_back( InputVertex(azi, alt, c) ); + ref_vertices.push_back( InputVertex(azi, alt, c) ); if (val_limit > 0 && val_records_read > val_limit) { std::push_heap( - arr_vertex->begin(), arr_vertex->end(), + ref_vertices.begin(), ref_vertices.end(), GreaterBrightness() ); - arr_vertex->pop_back(); + ref_vertices.pop_back(); val_min_brightness = getBrightness( - arr_vertex->begin()->getColor() ); + ref_vertices.begin()->getColor() ); } } else @@ -433,9 +433,9 @@ namespace class TileCulling { Renderer& ref_renderer; - Tile** ptr_stack; + Tile** itr_stack; Tile const* const arr_tile; - Tile const* const ptr_tiles_end; + Tile const* const itr_tiles_end; public: @@ -454,7 +454,7 @@ namespace void up(Tile*& cursor) const { cursor += yStride(); } void down(Tile*& cursor) const { cursor -= yStride(); } - void defer(Tile* t) { *ptr_stack++ = t; } + void defer(Tile* t) { *itr_stack++ = t; } inline bool deferred(Tile*& cursor); private: @@ -787,12 +787,12 @@ namespace Tile const* tiles, Tile const* tiles_end, Tile** stack) : ref_renderer(renderer), - ptr_stack(stack), arr_tile(tiles), ptr_tiles_end(tiles_end) + itr_stack(stack), arr_tile(tiles), itr_tiles_end(tiles_end) { } bool TileCulling::select(Tile* t) { - if (t < arr_tile || t >= ptr_tiles_end || + if (t < arr_tile || t >= itr_tiles_end || !! (t->flags & Tile::visited)) return false; @@ -808,9 +808,9 @@ namespace bool TileCulling::deferred(Tile*& cursor) { - if (ptr_stack != (Tile**) ref_renderer.arr_batch_count) + if (itr_stack != (Tile**) ref_renderer.arr_batch_count) { - cursor = *--ptr_stack; + cursor = *--itr_stack; return true; } return false; @@ -824,7 +824,7 @@ namespace struct Stars::body { - InputVertices vec_input; + InputVertices seq_input; unsigned val_tile_resolution; BrightnessLevels vec_lod_brightness; @@ -857,7 +857,7 @@ struct Stars::body { // TODO input mutex - vec_input.swap(new_vertices); + seq_input.swap(new_vertices); try { @@ -866,7 +866,7 @@ struct Stars::body catch (...) { // rollback transaction - new_vertices.swap(vec_input); + new_vertices.swap(seq_input); throw; } @@ -894,9 +894,9 @@ struct Stars::body { HorizontalTiling tiling(k); TileSortScanner scanner(tiling); - radix2InplaceSort(vec_input.begin(), vec_input.end(), scanner); + radix2InplaceSort(seq_input.begin(), seq_input.end(), scanner); - recreateRenderer(vec_input.size(), k, + recreateRenderer(seq_input.size(), k, val_lod_brightness, val_lod_max_brightness); val_tile_resolution = k; @@ -944,7 +944,7 @@ struct Stars::body void recreateRenderer( size_t n, unsigned k, BrightnessLevel b, BrightnessLevel b_max) { - Renderer* renderer = new Renderer(vec_input, n, k, b, b_max); + Renderer* renderer = new Renderer(seq_input, n, k, b, b_max); swap(ptr_renderer, renderer); // TODO make atomic delete renderer; // will be NULL when was in use } diff --git a/shared/src/UrlReader.cpp b/shared/src/UrlReader.cpp index 4b16081fb0..ea602f6796 100644 --- a/shared/src/UrlReader.cpp +++ b/shared/src/UrlReader.cpp @@ -23,10 +23,10 @@ char const* const UrlReader::error_leftover_input = "UrlReader: Incomplete pro #define hnd_curl static_cast(ptr_impl) UrlReader::UrlReader() - : ptr_impl(0l), ptr_ra(0l), str_error(0l) + : ptr_impl(0l), buf_xtra(0l), str_error(0l) { - ptr_ra = new(std::nothrow) char[max_read_ahead]; - if (! ptr_ra) { str_error = error_init_failed; return; } + buf_xtra = new(std::nothrow) char[max_read_ahead]; + if (! buf_xtra) { str_error = error_init_failed; return; } ptr_impl = curl_easy_init(); if (! ptr_impl) { str_error = error_init_failed; return; } curl_easy_setopt(hnd_curl, CURLOPT_NOSIGNAL, 1l); @@ -36,7 +36,7 @@ UrlReader::UrlReader() UrlReader::~UrlReader() { - delete ptr_ra; + delete buf_xtra; if (! hnd_curl) return; curl_easy_cleanup(hnd_curl); } @@ -51,7 +51,7 @@ bool UrlReader::perform(char const* url, transfer_callback* cb) if (rc == CURLE_OK) { - while (val_ra_size > 0 && str_error == success) + while (val_xtra_size_size > 0 && str_error == success) cb(0l, 0, 0, this); } else if (str_error == success) diff --git a/shared/src/UrlReader.h b/shared/src/UrlReader.h index 273302bb7e..94f14b3760 100644 --- a/shared/src/UrlReader.h +++ b/shared/src/UrlReader.h @@ -20,10 +20,10 @@ class UrlReader { void* ptr_impl; - char* ptr_ra; + char* buf_xtra; char const* str_error; void* ptr_stream; - size_t val_ra_size; + size_t val_xtra_size_size; public: @@ -154,7 +154,7 @@ bool UrlReader::readUrl(char const* url, ContentStream& s) if (! ptr_impl) return false; str_error = success; ptr_stream = & s; - val_ra_size = ~size_t(0); + val_xtra_size_size = ~size_t(0); this->perform(url, & callback_template); s.end(str_error == success); return str_error == success; @@ -178,9 +178,9 @@ size_t UrlReader::callback_template( Stream* stream = static_cast(me->ptr_stream); // first call? - if (me->val_ra_size == ~size_t(0)) + if (me->val_xtra_size_size == ~size_t(0)) { - me->val_ra_size = 0u; + me->val_xtra_size_size = 0u; // extract meta information and call 'begin' char const* url, * type; int64_t length, stardate; @@ -196,15 +196,15 @@ size_t UrlReader::callback_template( size_t bytes = size - input_offset; // data in extra buffer? - if (me->val_ra_size > 0) + if (me->val_xtra_size_size > 0) { // fill extra buffer with beginning of input - size_t fill = max_read_ahead - me->val_ra_size; + size_t fill = max_read_ahead - me->val_xtra_size_size; if (bytes < fill) fill = bytes; - memcpy(me->ptr_ra + me->val_ra_size, buffer, fill); + memcpy(me->buf_xtra + me->val_xtra_size_size, buffer, fill); // use extra buffer for next transfer - buffer = me->ptr_ra; - bytes = me->val_ra_size + fill; + buffer = me->buf_xtra; + bytes = me->val_xtra_size_size + fill; input_offset += fill; } @@ -223,9 +223,9 @@ size_t UrlReader::callback_template( size_t unprocessed = bytes - processed; // can switch to input buffer, now? - if (buffer == me->ptr_ra && unprocessed <= input_offset) + if (buffer == me->buf_xtra && unprocessed <= input_offset) { - me->val_ra_size = 0u; + me->val_xtra_size_size = 0u; input_offset -= unprocessed; } else // no? unprocessed data -> extra buffer @@ -235,10 +235,10 @@ size_t UrlReader::callback_template( me->setError(error_buffer_overflow); return 0; } - me->val_ra_size = unprocessed; - memmove(me->ptr_ra, buffer + processed, unprocessed); + me->val_xtra_size_size = unprocessed; + memmove(me->buf_xtra, buffer + processed, unprocessed); - if (input_offset == size || buffer != me->ptr_ra) + if (input_offset == size || buffer != me->buf_xtra) { return size; }