HeeroYui-deprecated/astyle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add ample code examples in correct_style.cpp

Browse Source
This commit is contained in:
Peter Vingelmann 2016-09-28 03:26:12 +02:00
parent 90757717a5
commit d39345f7cd
2 changed files with 580 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

664
test/correct_style.cpp
View File

@ -1,8 +1,13 @@
// Copyright comment
#pragma once
#include <iostream>
#include <vector>
#include <cstdint>
#include <string>
// Indented preprocessor statements
#if defined(PLATFORM_WINDOWS_PHONE)
#if defined(PLATFORM_MSVC_ARM)
// NEON introduced in VS2012
@ -25,8 +30,12 @@
#endif
#endif
namespace kodo_core
// Namespaces
namespace test
{
// Using expressions
/// @ingroup finite_field_layers
///
/// @brief Template alias for the common set of finite field
@ -34,11 +43,9 @@ namespace kodo_core
template<class Field, class SuperCoder>
using finite_field_layers =
finite_field_math<typename fifi::default_field<Field>::type,
// Test comment
finite_field<Field, SuperCoder>>;
}
namespace kodo_rlnc
{
/// @ingroup coefficient_generator_layers
///
/// @brief Generates an uniform random coefficient (from the
@ -49,13 +56,21 @@ namespace kodo_rlnc
template<class Features, class SuperCoder>
using on_the_fly_generator =
kodo_core::check_partial_generator<
// Test comment
kodo_core::uniform_generator_layers::type<Features,
kodo_core::pivot_aware_generator<
SuperCoder> > >;
}
namespace kodo_rlnc
{
// Expression with template disambiguator
using type = typename std::conditional<
Predicate<T>::value,
typename conditional_append<Predicate,
typename TypeList::template append<T>, List...>::type,
typename conditional_append<Predicate,
TypeList, List...>::type>::type;
// Template stacks
template
<
class MainStack,
@ -85,22 +100,68 @@ class full_vector_recoding_stack : public
kodo_core::final_layer
> > > > > > > > > > > > >
{ };
template<class T>
struct is_regular :
// Comment 2
std::integral_constant<bool,
// Comment 3
std::is_default_constructible<T>::value &&
// Comment 4
std::is_move_assignable<T>::value>
{ };
class client : public
links::message_handler<links::message,
message_printer<
links::link
>>
{
protected:
/// Helper struct to determine if two classes have the same field types
template<class T>
struct is_same_field
{
static const bool value =
std::is_same<typename T::field_type, field_type>::value;
};
};
}
namespace fifi
// Nested namespaces
namespace test
{
template
<
class T,
typename std::enable_if<has_region_multiply_constant<T>::value,
uint8_t>::type = 0
>
inline void region_multiply_constant(T& t, uint8_t* dest,
typename T::value_type constant,
uint32_t size)
namespace api
{
t.region_multiply_constant(dest, constant, size);
inline std::shared_ptr<final_interface> build(final_interface* stack)
{
auto api = dynamic_cast<build_interface*>(stack);
assert(api);
return api->build();
}
}
namespace
{
struct dummy_one
{
template<class Factory>
void construct(Factory& the_factory)
{
(void) the_factory;
m_construct();
}
stub::function<void()> m_construct;
};
}
}
// Free functions
/// @copydoc layer::multipy_add(uint8_t*, const uint8_t*,
/// value_type, uint32_t)
@ -118,42 +179,341 @@ void multiply_add(uint8_t* symbol_dest,
m_field->region_multiply_add(symbol_dest, symbol_src, coefficient,
symbol_size);
}
template<class R, class... FArgs, class... Args>
inline auto easy_bind(std::function<R(FArgs...)> f, Args&&... args) ->
decltype(detail::easy_bind(
detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
f, std::forward<Args>(args)...))
{
return detail::easy_bind(
detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
f, std::forward<Args>(args)...);
}
namespace magic
template<typename U>
static auto test(int) ->
decltype(std::declval<U>().some_function(), yes());
template<class SuperCoder>
inline auto
vandermonde_matrix_base::config::construct_matrix(uint32_t symbols) ->
std::shared_ptr<generator_matrix>
{
// Something
}
template<
class Field,
class TraceTag
>
auto coder(const std::string& name) ->
boost::python::class_<Coder<Field, TraceTag>, boost::noncopyable>
{
// Something
}
template<std::size_t... Is, class F, class... Args>
inline auto easy_bind(indices<Is...>, F const& f, Args&&... args) ->
decltype(std::bind(
f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...))
{
return std::bind(
f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...);
}
template <typename R, typename T, typename... FArgs, typename... Args>
inline auto easy_bind(R(T::*mf)(FArgs...), Args&&... args) ->
decltype(detail::easy_bind(
detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
mf, std::forward<Args>(args)...))
{
// The extra argument is the object pointer (this)
static_assert(sizeof...(Args) <= sizeof...(FArgs) + 1,
"Too many arguments to easy_bind");
return detail::easy_bind(
detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
mf, std::forward<Args>(args)...);
}
template
<
class T,
typename std::enable_if<has_region_multiply_constant<T>::value,
uint8_t>::type = 0
>
inline void region_multiply_constant(T& t, uint8_t* dest,
typename T::value_type constant,
uint32_t size)
{
t.region_multiply_constant(dest, constant, size);
}
template
<
typename... Types,
// Comment 1
typename I = std::make_index_sequence<
// Comment 2
std::tuple_size<std::tuple<Types...>>::value>
>
constexpr auto tuple_to_array(std::tuple<Types...>&& tuple);
#ifdef __cplusplus
extern "C"
{
#endif
KODOC_API
uint8_t kodoc_has_write_payload(kodoc_coder_t coder);
KODOC_API
void kodoc_set_mutable_symbols(
kodoc_coder_t decoder, uint8_t* data, uint32_t size);
#ifdef __cplusplus
}
#endif
namespace fifi
{
#ifdef PLATFORM_AVX2
namespace detail
{
inline void multiply_helper(__m256i& low, __m256i& high,
__m256i*& table_ptr, __m256i& sum)
{
__m256i table1, table2;
__m256i h, l, product;
// Load the 32-byte row that contains the pre-calculated
// multiplication results with the low-half of the constant
table1 = _mm256_loadu_si256(table_ptr++);
}
}
#else
avx2_binary8_full_table::avx2_binary8_full_table()
{
(void) m_table_one;
(void) m_table_two;
}
void avx2_binary8_full_table::region_add(
uint8_t*, const uint8_t*, uint32_t) const
{
// Not implemented
assert(0 && "This line should never be executed");
}
#endif
}
// Enum
enum error_type
{
failed_open_file = 1,
failed_open_file = 2
};
// Normal class
class my_class
{
public:
stub::function<uint32_t, const storage::const_storage> copy_into_symbol;
stub::function<
void(uint8_t**, const uint8_t**, uint8_t**,
uint32_t, uint32_t, uint32_t)
> m_vector_dot_product;
stub::function<
void (uint8_t*, const uint8_t*, value_type, uint32_t)
> multiply_add;
// Constructors
my_class() :
m_value(0U),
m_first(0U),
m_second(1U)
{ }
uint32_t value() const
my_class() :
m_vector { 1, 2, 3, 4 },
m_second(1U)
{ }
// Make sure that this base class cannot be instantiated
factory(kodoc_factory_t factory,
std::function<void(kodoc_factory_t)> deleter) :
m_factory(factory, deleter)
{ }
decoder_factory(codec codec, field field,
uint32_t max_symbols, uint32_t max_symbol_size) :
factory(kodoc_new_decoder_factory(
(int32_t)codec, (int32_t)field, max_symbols, max_symbol_size),
[](kodoc_factory_t factory) { kodoc_delete_factory(factory); })
{ }
io_service() :
m_io_service(
score_new_io_service(), [](score_io_service_t io)
{
score_delete_io_service(io);
})
{ }
io_service() :
m_io_service(
score_new_io_service(),
{
1, 2, 3
})
{ }
template
<
class T = Value,
typename std::enable_if<
std::is_default_constructible<T>::value, uint8_t>::type = 0
>
resource_pool() :
m_pool(std::make_shared<impl>(
allocate_function(std::make_shared<value_type>)))
{ }
public:
// Function calls
void function_calls()
{
return m_value;
srand(static_cast<uint32_t>(time(0)));
assert(m_socket && "Invalid socket in queue_async_receive");
assert(cancelled == 0 &&
"Rate limiter send called multiple times without "
"waiting for callback!");
m_timer->async_wait(std::bind(&rate_limiter::timeout_handler,
this, std::placeholders::_1, callback));
namespace ph = std::placeholders;
m_socket->async_receive_from(
boost::asio::buffer(m_receive_buffer), *ep, std::bind(
&sockets::handle_async_receive_from, this,
ph::_1, ph::_2, ep));
m_redundancy_estimator.sample(
(1.0 + m_redundancy_estimator.estimate()) *
m_generation_size() / m_worst.get() - 1.0);
m_formatters.insert(std::make_pair(
"csv", std::shared_ptr<tables::format>(new tables::csv_format())),
third_param);
EXPECT_TRUE(main_stack->copy_from_symbols.expect_calls().with(
storage::storage(data))
.to_bool());
// Before function
m_socket->async_receive_from(
// Line 1
looooooooooooooooong_function_name1(m_receive_buffer),
// Line 2
{ 1, 2, 3, 4 },
// Line 3
looooooooooooooooong_function_name2(
// Line 4
&sockets::handle_async_receive_from, this,
ph::_1, ph::_2, ep));
// Initializer block within a function call
m_output_queue.insert(m_output_queue.begin(),
vector { 1, 2, 3 });
m_output_queue.insert(m_output_queue.begin(),
{
1, 2, 3
},
more);
// Examples for non-optimal manual layout. The lines should be broken
// after the '(' to get decent layout.
score::generation_storage_in::coder_type::factory factory(symbol_size,
generation_size);
boost::asio::ip::multicast::join_group option(addr,
score::manual_sender::address_type());
}
void set_value(uint32_t value)
// Assignments and arithmetics
void assignments()
{
m_value = value;
m_pep = m_pep * std::pow(base, losses + 1.0) +
(1.0 - std::pow(base, losses));
m_worst =
(m_worst) ? std::max(*m_worst, s.m_rank) : s.m_rank;
bool binary_ext_fields =
std::is_same<field_type, fifi::binary4>::value ||
std::is_same<field_type, fifi::binary8>::value;
double time = static_cast<double>(
boost::chrono::duration_cast<boost::chrono::microseconds>(
m_total_stop-m_total_start).count());
statistics iter = calculate_statistics(iterations.cbegin(),
iterations.cend());
bool result = std::equal(input_buffer.begin(), input_buffer.end(),
output_buffer.begin());
m_socket->async_receive_from(
looooooooooooooooong_function_name1(alpha) <
looooooooooooooooong_function_name2(beta));
std::shared_ptr<endpoint_type> ep =
std::make_shared<endpoint_type>();
using rlnc_decoder = kodo_rlnc::full_vector_decoder<
fifi::binary, fifi::binary4, fifi::binary8>;
uint8_t constant_matrix[3][3] =
{
{1, 2, 3},
{5, 6, 7},
{53, 71, 42}
};
expected_coefficients =
{ 95, 203, 243, 46, 187, 199, 153, 152, 39, 114 };
EXXXXXXXXECT_EQ(1u, stack.m_send.calls()) <<
"Only one packet be send as " <<
"io service is not run yet";
out << "\t\t" << "dest = " << ((uintptr_t) std::get<0>(v))
<< " src = " << ((uintptr_t) std::get<1>(v))
<< " length = " << ((uint32_t) std::get<2>(v)) << std::endl;
std::cout << "This is a very looooooong line for this Hello World! " <<
"string string" << num << std::endl;
}
// Return statements
void return_statements()
{
return looooooooooooooooong_function_name(
alpha + beta);
return detail::easy_bind(
detail::build_indices<sizeof...(Args)>(),
mf, std::forward<Args>(args)...);
}
// Control flow and special blocks
void blocks()
{
if (coffee_pot == full &&
second_condition::value &&
third_condition::value)
@ -161,6 +521,36 @@ public:
continue;
}
while (foundAssignmentOp->length() <
foundNonAssignmentOp->length())
{
foundAssignmentOp = NULL;
}
for (const auto& item : m_snack_list)
{
item.write(writer, m_current_generation);
}
for (auto it = stored_snacks.lower_bound(feedback_generation - rtt);
it != stored_snacks.end(); ++it)
{
lowest_rank = std::min(it->second, lowest_rank);
}
switch (other.m_type)
{
case class_type::object:
m_internal.m_map =
new json::object_type(
other.m_internal.m_map->begin(),
other.m_internal.m_map->end());
break;
default:
// Something
break;
}
try
{
my_function();
@ -174,71 +564,175 @@ public:
// handles int or std::string or any other unrelated type
}
m_redundancy_estimator.sample(
(1.0 + m_redundancy_estimator.estimate()) *
m_generation_size() / m_worst.get() - 1.0);
// Alignment for commas
int a, b, c,
d, e, f;
m_worst =
(m_worst) ? std::max(*m_worst, s.m_rank) : s.m_rank;
// This is a block with an arbitrary macro header
RUN
{
max_value = *std::max_element(std::begin(m_container),
std::end(m_container));
m_redundancy_estimator.sample(
(1.0 + m_redundancy_estimator.estimate()) *
m_generation_size() / m_worst.get() - 1.0);
bool alpha = beta +
gamma;
return beta +
gamma;
}
}
/// Queues an async receive call on the socket
void queue_async_receive()
// Lambda functions
void lambda_functions()
{
assert(m_socket && "Invalid socket in queue_async_receive");
// Standalone lambdas
assert(cancelled == 0 &&
"Rate limiter send called multiple times without "
"waiting for callback!");
auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
{
EXPECT_TRUE((bool) o);
++recycled;
};
namespace ph = std::placeholders;
auto callback = [function](const std::string& zone,
const std::string& message)
{
boost::python::call<void>(function, zone, message);
};
m_receive_buffer.resize(receive_buffer_size, 0u);
auto callback = [function](
const std::string& zone, const std::string& message)
{
boost::python::call<void>(function, zone, message);
};
std::shared_ptr<endpoint_type> ep =
std::make_shared<endpoint_type>();
auto compare = [](const parameter& a, const parameter& b) -> bool
{
if (std::get<0>(a) != std::get<0>(b))
return false;
};
m_timer->async_wait(std::bind(&rate_limiter::timeout_handler,
this, std::placeholders::_1, callback));
// Single-line lambdas
m_socket->async_receive_from(
boost::asio::buffer(m_receive_buffer), *ep, std::bind(
&sockets::handle_async_receive_from, this,
ph::_1, ph::_2, ep));
std::function<uint32_t()> m_delay_generator =
[]() { return 0; };
m_output_queue.insert(m_output_queue.begin(),
queue_item(repair, []() {}));
std::generate(data.begin(), data.end(),
[&]() { return randval(engine); });
in.fetch_data_ready(
[&](std::vector<uint8_t>& cb) { fetch_data_ready_stub(cb); });
// Lambda blocks as function arguments
sender.flush([&io]()
{
io.stop();
std::cout << "IO service stopped." << std::endl;
});
s.write_data(buffer, [&]()
{
io.post(write_data_callback);
});
m_io_thread = std::make_shared<std::thread>([&]
{
m_io_service.run();
});
auto cmp = stub::make_compare([](const cup& c)->bool
{
return c.m_volume == 2.3;
});
// Lambda within a lambda
deleter = [](kodoc_factory_t factory)
{
kodoc_delete_factory(factory);
auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
{
EXPECT_TRUE((bool) o);
++recycled;
};
}
}
// Standalone template expressions
void standalone_templates()
{
run_test_basic_api<
// Line 1
Encoder<fifi::binary>,
// Line 2
Decoder<fifi::binary>
>(symbols, symbol_size);
parser<
box::moov<parser<
box::trak<parser<
box::mdia<parser<
box::hdlr,
box::mdhd
>>
>>
>>
> parser;
{
SCOPED_TRACE(testing::Message() << "field = binary");
run_test_basic_api<
Encoder<fifi::binary>,
// Line 2
Decoder<fifi::binary>
>(symbols, symbol_size);
}
}
template
<
class T = Value,
typename std::enable_if<
std::is_default_constructible<T>::value, uint8_t>::type = 0
>
resource_pool() :
m_pool(std::make_shared<impl>(
allocate_function(std::make_shared<value_type>)))
{ }
protected:
private:
// Member variables
uint32_t m_value;
std::function<void(const std::vector<uint8_t>&)> m_write_symbol_callback;
stub::function<uint32_t, const storage::const_storage> copy_into_symbol;
stub::function<
void(uint8_t**, const uint8_t**, uint8_t**, uint32_t, uint32_t)
> m_vector_dot_product;
stub::function<
void (uint8_t*, const uint8_t*, value_type, uint32_t)
> multiply_add;
};
}
/// Test that our resource pool is a regular type. We are not
/// implementing equality or less than here, but maybe we could.
namespace
{
template<class T>
struct is_regular :
std::integral_constant<bool,
std::is_default_constructible<T>::value &&
std::is_copy_constructible<T>::value &&
std::is_move_constructible<T>::value &&
std::is_copy_assignable<T>::value &&
std::is_move_assignable<T>::value>
{ };
}
// gtest macros
INSTANTIATE_TEST_CASE_P(/* symbol_size */,
test_message_serialize_parse_param,
::testing::Values(/*4u, 10U, 15U, 30U,*/
150U, 300U, 500U,
1500U, 3000U, 5000U));
INSTANTIATE_TEST_CASE_P(
/* symbol_size */,
test_message_serialize_parse_param,
::testing::Values(
/*4u, 10U, 15U, 30U,*/
150U, 300U, 500U,
1500U, 3000U, 5000U));
// Main function body
int main(int argc, const char* argv[])
{
@ -250,6 +744,8 @@ int main(int argc, const char* argv[])
++recycled;
};
std::vector<int> v = {0, 1, 2, 3, 4, 5};
std::vector<uint8_t> data =
{
0x67, 0x42, 0x00, 0x0A, 0xF8, 0x41, 0xA2
@ -259,8 +755,6 @@ int main(int argc, const char* argv[])
std::cout << "This is a very loooooooooong line for this Hello World! "
<< num << std::endl;
std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (int& i : v)
std::cout << i << ' ';

2
wscript
View File

@ -94,7 +94,7 @@ def run_astyle_tests(bld):
# Run astyle to format each test file
for file in sorted(os.listdir(temp_folder)):
test_file = os.path.join(temp_folder, file)
if (os.path.isfile(test_file)):
if os.path.isfile(test_file):
print('Test file: '+test_file)
run_command([astyle, options, test_file])