diff --git a/adobe/any_regular.hpp b/adobe/any_regular.hpp index 3c0f08d0..595ed064 100644 --- a/adobe/any_regular.hpp +++ b/adobe/any_regular.hpp @@ -687,13 +687,12 @@ inline bool empty(const any_regular_t& x) { return x.type_info() == typeid(empty template struct runtime_cast_t { R operator()(const any_regular_t& x) const { - typedef typename boost::remove_const::type>::type - result_type; + using result_type = std::remove_const_t>; - static_assert(boost::is_reference::value); + static_assert(std::is_reference_v); /* There is no auto-promotion through the new interface. Soon promotion will be disabled. */ - static_assert(std::is_same::type, result_type>::value); + static_assert(std::is_same_v::type, result_type>); return x.cast(); } @@ -704,9 +703,9 @@ struct runtime_cast_t { template struct runtime_cast_t { R operator()(any_regular_t& x) const { - typedef typename boost::remove_reference::type result_type; + using result_type = std::remove_reference_t; - static_assert(boost::is_reference::value); + static_assert(std::is_reference_v); /* There is no auto-promotion through the new interface. Soon promotion will be disabled. */ static_assert(std::is_same::type, result_type>::value); @@ -720,9 +719,9 @@ struct runtime_cast_t { template struct runtime_cast_t { R operator()(any_regular_t* x) const { - typedef typename boost::remove_pointer::type result_type; + using result_type = std::remove_pointer_t; - static_assert(boost::is_pointer::value); + static_assert(std::is_pointer_v); /* There is no auto-promotion through the new interface. Soon promotion will be disabled. */ static_assert(std::is_same::type, result_type>::value); @@ -736,13 +735,12 @@ struct runtime_cast_t { template struct runtime_cast_t { R operator()(const any_regular_t* x) const { - typedef - typename boost::remove_const::type>::type result_type; + using result_type = std::remove_const_t>; - static_assert(boost::is_pointer::value); + static_assert(std::is_pointer_v); /* There is no auto-promotion through the new interface. Soon promotion will be disabled. */ - static_assert(std::is_same::type, result_type>::value); + static_assert(std::is_same_v::type, result_type>); if (x->type_info() != typeid(result_type)) return 0; diff --git a/adobe/arg_stream.hpp b/adobe/arg_stream.hpp index f756da97..219a5374 100644 --- a/adobe/arg_stream.hpp +++ b/adobe/arg_stream.hpp @@ -6,9 +6,7 @@ #ifndef ADOBE_ARG_STREAM_H #define ADOBE_ARG_STREAM_H -#include #include -#include #include #include @@ -195,26 +193,13 @@ struct signature> { typedef F type; }; -/*! -\ingroup arg_stream - -\brief result_type::type is the return type of the function f. - -\template_parameters - - \c F models callable object -*/ -template -struct result_type { - typedef typename boost::function_types::result_type::type>::type type; -}; - namespace detail { // how it all works... - template -struct remove_cv_ref : boost::remove_cv::type> {}; - +struct remove_cv_ref { + using type = std::remove_cv_t>; +}; // see also boost::function_types 'interpreter' example // we convert the function signature into a mpl sequence (it *is* an mpl sequence, since it @@ -231,7 +216,7 @@ template - static inline typename result_type::type apply(F func, ArgStream& astream, + static inline auto apply(F func, ArgStream& astream, Args const& args) { typedef typename remove_cv_ref::type>::type arg_type; typedef typename boost::mpl::next::type next_iter_type; @@ -245,7 +230,7 @@ struct invoker { template struct invoker { template - static inline typename result_type::type apply(F func, ArgStream&, Args const& args) { + static inline auto apply(F func, ArgStream&, Args const& args) { return boost::fusion::invoke(func, args); } }; @@ -262,7 +247,7 @@ struct invoker { abstracted object. */ template -typename result_type::type call(F f, ArgStream& astream) { +auto call(F f, ArgStream& astream) { return detail::invoker::apply(f, astream, boost::fusion::nil()); } @@ -272,7 +257,7 @@ typename result_type::type call(F f, ArgStream& astream) { \brief specialization of arg_stream::call for handling member function calls. */ template -typename result_type::type call(T* that, F f, ArgStream& astream) { +auto call(T* that, F f, ArgStream& astream) { // object gets pushed on as first arg of fusion list, // and remove first arg from signature (the object that the member function belongs to) // using diff --git a/adobe/cstdint.hpp b/adobe/cstdint.hpp deleted file mode 100644 index 198b8d87..00000000 --- a/adobe/cstdint.hpp +++ /dev/null @@ -1,36 +0,0 @@ -/* - Copyright 2013 Adobe - Distributed under the Boost Software License, Version 1.0. - (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -*/ -/**************************************************************************************************/ - -#ifndef ADOBE_CSTDINT_HPP -#define ADOBE_CSTDINT_HPP - -#include - -#include - -/**************************************************************************************************/ - -namespace adobe { - -/*! -\defgroup tr1 TR1 Components -\ingroup utility -@{ -*/ - -/**************************************************************************************************/ - -[[deprecated]] using std::intptr_t; -[[deprecated]] using std::uintptr_t; - -//! @} -/**************************************************************************************************/ -} // namespace adobe - -/**************************************************************************************************/ - -#endif diff --git a/adobe/string_fwd.hpp b/adobe/string_fwd.hpp deleted file mode 100644 index 884a1601..00000000 --- a/adobe/string_fwd.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/* - Copyright 2013 Adobe - Distributed under the Boost Software License, Version 1.0. - (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -*/ -/**************************************************************************************************/ - -#error Deprecated - -#ifndef ADOBE_STRING_FWD_HPP -#define ADOBE_STRING_FWD_HPP - -#ifdef ADOBE_STD_SERIALIZATION -#include -#endif - -/**************************************************************************************************/ - -namespace adobe { -inline namespace version_1 { - -/**************************************************************************************************/ - -class string_t; -class string16_t; - -/**************************************************************************************************/ - -} // namespace version_1 - -/**************************************************************************************************/ - -using version_1::string16_t; -using version_1::string_t; - -/**************************************************************************************************/ - - -/**************************************************************************************************/ - -} // namespace adobe - -/**************************************************************************************************/ - -#endif - -/**************************************************************************************************/ diff --git a/adobe/vector.hpp b/adobe/vector.hpp deleted file mode 100644 index 875dbf31..00000000 --- a/adobe/vector.hpp +++ /dev/null @@ -1,535 +0,0 @@ -/* - Copyright 2013 Adobe - Distributed under the Boost Software License, Version 1.0. - (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -*/ -/**************************************************************************************************/ - -#error Deprecated -#ifndef ADOBE_VECTOR_HPP -#define ADOBE_VECTOR_HPP - -/**************************************************************************************************/ - -#include - -#include - -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include - -#ifdef ADOBE_STD_SERIALIZATION -#include -#endif - -/**************************************************************************************************/ - -namespace adobe { -inline namespace version_1 { - -/*! -\defgroup container Containers -\ingroup asl_libraries - */ - - -/**************************************************************************************************/ - -template // A models Allocator(T) -class vector : boost::totally_ordered, vector> { -public: - typedef T& reference; - typedef const T& const_reference; - typedef T* iterator; - typedef const T* const_iterator; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef T value_type; - typedef A allocator_type; - typedef T* pointer; - typedef const T* const_pointer; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - -private: - struct header_t { - struct compact_header_t { - boost::compressed_pair allocate_finish_m; - T* end_of_storage_m; - }; - aligned_storage header_m; - T storage_m[1]; - - allocator_type& allocator() { return header_m.get().allocate_finish_m.first(); } - const allocator_type& allocator() const { return header_m.get().allocate_finish_m.first(); } - - pointer& finish() { return header_m.get().allocate_finish_m.second(); } - const pointer& finish() const { return header_m.get().allocate_finish_m.second(); } - - pointer& end_of_storage() { return header_m.get().end_of_storage_m; } - const pointer& end_of_storage() const { return header_m.get().end_of_storage_m; } - }; - - header_t* header_m; - - void set_finish(T* x) { - assert(header_m != 0 || x == 0); - if (header_m) - header_m->finish() = x; - } - - const T* end_of_storage() const { return header_m ? header_m->end_of_storage() : 0; } - - static header_t* allocate(allocator_type, std::size_t); - - size_type remaining() const { return end_of_storage() - end(); } - - template // I models InputIterator - void append(I f, I l) { - append(f, l, typename std::iterator_traits::iterator_category()); - } - - template // I models InputIterator - void append(I f, I l, std::input_iterator_tag); - - template // I models ForwardIterator - void append(I f, I l, std::forward_iterator_tag); - - template // I models InputIterator - void append_move(I f, I l) { - append_move(f, l, typename std::iterator_traits::iterator_category()); - } - - template // I models InputIterator - void append_move(I f, I l, std::input_iterator_tag); - - template // I models ForwardIterator - void append_move(I f, I l, std::forward_iterator_tag); - - template // I models InputIterator - iterator insert(iterator p, I f, I l, std::input_iterator_tag); - - template // I models ForwardIterator - iterator insert(iterator p, I f, I l, std::forward_iterator_tag); - -public: - // 23.2.4.1 construct/copy/destroy - - explicit vector(const allocator_type& a) : header_m(allocate(a, 0)) {} - vector() : header_m(0) {} - - explicit vector(size_type n) : header_m(allocate(allocator_type(), n)) { - std::uninitialized_fill_n(end(), n, value_type()); - set_finish(end() + n); - } - - vector(size_type n, const value_type& x) : header_m(allocate(allocator_type(), n)) { - std::uninitialized_fill_n(end(), n, x); - set_finish(end() + n); - } - - vector(size_type n, const value_type& x, const allocator_type& a) : header_m(allocate(a, n)) { - std::uninitialized_fill_n(end(), n, x); - set_finish(end() + n); - } - - vector(const vector& x) : header_m(allocate(x.get_allocator(), x.size())) { -#ifndef NDEBUG - /* REVISIT (sparent) : MS stupid "safety check" doesn't known about empty ranges. */ - set_finish(x.begin() == x.end() ? end() - : std::uninitialized_copy(x.begin(), x.end(), end())); -#else - set_finish(std::uninitialized_copy(x.begin(), x.end(), end())); -#endif - } - - template // I models InputIterator - vector(I f, I l, typename boost::disable_if>::type* = 0) : header_m(0) { - append(f, l); - } - - template // I models InputIterator - vector(I f, I l, const allocator_type& a, - typename boost::disable_if>::type* = 0) - : header_m(allocate(a), 0) { - append(f, l); - } - - ~vector() { - if (header_m) { - clear(); - - typename allocator_type::template rebind::other alloc(get_allocator()); - alloc.deallocate(reinterpret_cast(header_m), - (end_of_storage() - begin()) * sizeof(T) + - (sizeof(header_t) - sizeof(T))); - } - } - - // adobe addition - - vector(move_from x) : header_m(x.header_m) { x.header_m = 0; } - - allocator_type get_allocator() const { - return header_m ? header_m->allocator() : allocator_type(); - } - - iterator begin() { return header_m ? &header_m->storage_m[0] : 0; } - iterator end() { return header_m ? header_m->finish() : 0; } - - const_iterator begin() const { return header_m ? &header_m->storage_m[0] : 0; } - const_iterator end() const { return header_m ? header_m->finish() : 0; } - - reverse_iterator rbegin() { return reverse_iterator(end()); } - reverse_iterator rend() { return reverse_iterator(begin()); } - - const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } - const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } - - size_type size() const { return size_type(end() - begin()); } - size_type max_size() const { return size_type(-1) / sizeof(value_type); } - - size_type capacity() const { return size_type(end_of_storage() - begin()); } - bool empty() const { return begin() == end(); } - - reference operator[](size_type n) { - assert(n < size()); - return *(begin() + n); - } - const_reference operator[](size_type n) const { - assert(n < size()); - return *(begin() + n); - } - - /* - REVISIT (sparent@adobe.com): at() explicitly omitted because it pulls in out_of_range - which inherits from logic_error and uses std::string. - */ - - vector& operator=(vector x) { - swap(x); - return *this; - } - - void reserve(size_type n); - - reference front() { - assert(!empty()); - return *begin(); - } - const_reference front() const { - assert(!empty()); - return *begin(); - } - - reference back() { - assert(!empty()); - return *(end() - 1); - } - const_reference back() const { - assert(!empty()); - return *(end() - 1); - } - - void push_back(value_type x) { append_move(&x, &x + 1); } - - void pop_back() { - assert(!empty()); - resize(size() - 1); - } - - void swap(vector& x) { std::swap(header_m, x.header_m); } - - iterator insert(iterator p, value_type x) { return insert_move(p, &x, &x + 1); } - - template // I models InputIterator - iterator insert(iterator p, I f, I l, - typename boost::disable_if>::type* = 0) { - return insert(p, f, l, typename std::iterator_traits::iterator_category()); - } - - template // I models ForwardIterator - iterator insert_move(iterator p, I f, I l); - - iterator insert(iterator p, size_type n, const T& x); - - iterator erase(iterator pos) { - assert(pos != end()); - return erase(pos, pos + 1); - } - - iterator erase(iterator f, iterator l); - - void clear() { erase(begin(), end()); } - - void resize(size_type n); - - void resize(size_type n, const value_type& x); - - friend inline bool operator==(const vector& x, const vector& y) { -#if defined(_MSC_VER) && _MSC_VER == 1600 && _ITERATOR_DEBUG_LEVEL != 0 - return (x.size() == y.size()) && - std::_Equal1(x.begin(), x.end(), y.begin(), std::false_type()); -#else - return (x.size() == y.size()) && std::equal(x.begin(), x.end(), y.begin()); -#endif - } - - friend inline bool operator<(const vector& x, const vector& y) { - return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); - } - - friend inline void swap(vector& x, vector& y) { x.swap(y); } -}; - -template -typename vector::header_t* vector::allocate(allocator_type a, std::size_t n) { - if (n == 0) { - if (a == allocator_type()) - return 0; - n = 1; - } - - typename allocator_type::template rebind::other alloc(a); - - header_t* result = - reinterpret_cast(alloc.allocate(sizeof(header_t) - sizeof(T) + n * sizeof(T))); - construct(&result->allocator(), a); - result->finish() = &result->storage_m[0]; - result->end_of_storage() = result->finish() + n; - - return result; -} - -template -template // I models InputIterator -void vector::append(I f, I l, std::input_iterator_tag) { - while (f != l) { - push_back(*f); - ++f; - } -} - -template -template // I models InputIterator -void vector::append_move(I f, I l, std::input_iterator_tag) { - while (f != l) { - push_back(adobe::move(*f)); - ++f; - } -} - -template -template // I models ForwardIterator -void vector::append(I f, I l, std::forward_iterator_tag) { - size_type n(std::distance(f, l)); - - if (remaining() < n) - reserve((adobe::max)(size() + n, 2 * size())); - set_finish(std::uninitialized_copy(f, l, end())); -} - -template -template // I models ForwardIterator -void vector::append_move(I f, I l, std::forward_iterator_tag) { - size_type n(std::distance(f, l)); - - if (remaining() < n) - reserve((adobe::max)(size() + n, 2 * size())); - set_finish(adobe::uninitialized_move(f, l, end())); -} - -template -template // I models InputIterator -typename vector::iterator vector::insert(iterator p, I f, I l, - std::input_iterator_tag) { - size_type o(p - begin()); - size_type s = size(); - append(f, l); - // REVISIT (sparent) : This could be a move based rotate - std::rotate(begin() + o, begin() + s, end()); - return end() - s + o; -} - -template -template // I models ForwardIterator -typename vector::iterator vector::insert(iterator p, I f, I l, - std::forward_iterator_tag) { - size_type n(std::distance(f, l)); - iterator last = end(); - size_type before = p - begin(); - - if (remaining() < n) { - vector tmp; - tmp.reserve((adobe::max)(size() + n, 2 * size())); - tmp.append_move(begin(), p); - tmp.append(f, l); - tmp.append_move(p, last); - swap(tmp); - } else { - size_type after(last - p); - - if (n < after) { - append_move(last - n, last); - adobe::move_backward(p, last - n, last); - std::copy(f, l, p); - } else { - I m = f; - std::advance(m, after); - append(m, l); - append_move(p, last); - std::copy(f, m, p); - } - } - return begin() + before + n; -} - -template -template // I models ForwardIterator -typename vector::iterator vector::insert_move(iterator p, I f, I l) { - size_type n(std::distance(f, l)); - iterator last = end(); - size_type before = p - begin(); - - if (remaining() < n) { - vector tmp; - tmp.reserve((adobe::max)(size() + n, 2 * size())); - tmp.append_move(begin(), p); - tmp.append_move(f, l); - tmp.append_move(p, last); - swap(tmp); - } else { - size_type after(last - p); - - if (n < after) { - append_move(last - n, last); - move_backward(p, last - n, last); - adobe::move(f, l, p); - } else { - I m = f; - std::advance(m, after); - append_move(m, l); - append_move(p, last); - adobe::move(f, m, p); - } - } - return begin() + before + n; -} - -template -void vector::reserve(size_type n) { - if (capacity() < n) { - vector tmp; - tmp.header_m = allocate(get_allocator(), n); - tmp.header_m->finish() = adobe::uninitialized_move(begin(), end(), tmp.end()); - swap(tmp); - } -} - -template -typename vector::iterator vector::insert(iterator p, size_type n, const T& x) { - iterator last = end(); - size_type before = p - begin(); - - if (remaining() < n) { - vector tmp; - tmp.reserve((adobe::max)(size() + n, 2 * size())); - tmp.append_move(begin(), p); - std::uninitialized_fill_n(tmp.end(), n, x); - tmp.set_finish(tmp.end() + n); - tmp.append_move(p, last); - swap(tmp); - } else { - size_type after(last - p); - - if (n < after) { - append_move(last - n, last); - adobe::move_backward(p, last - n, last); - std::fill_n(p, n, x); - } else { - std::uninitialized_fill_n(last, n - after, x); - set_finish(last + (n - after)); - append_move(p, last); - std::fill_n(p, after, x); - } - } - return begin() + before + n; -} - -template -typename vector::iterator vector::erase(iterator f, iterator l) { - iterator i = adobe::move(l, end(), f); - for (iterator b(i), e(end()); b != e; ++b) { - b->~value_type(); - } - set_finish(i); - return f; -} - -template -void vector::resize(size_type n) { - if (n < size()) - erase(begin() + n, end()); - else - insert(end(), n - size(), value_type()); -} - -template -void vector::resize(size_type n, const value_type& x) { - if (n < size()) - erase(begin() + n, end()); - else - insert(end(), n - size(), x); -} - -/**************************************************************************************************/ - -#ifdef ADOBE_STD_SERIALIZATION - -template -std::ostream& operator<<(std::ostream& out, const vector& x) { - out << begin_sequence; - - for (typename vector::const_iterator first(x.begin()), last(x.end()); first != last; - ++first) { - out << format(*first); - } - - out << end_sequence; - - return out; -} - -#endif - -/**************************************************************************************************/ - -static_assert(sizeof(vector) == sizeof(void*)); - -/**************************************************************************************************/ - -} // namespace version_1 -} // namespace adobe - -/**************************************************************************************************/ - -ADOBE_NAME_TYPE_1("vector:version_1:adobe", - adobe::version_1::vector>) -ADOBE_NAME_TYPE_2("vector:version_1:adobe", adobe::version_1::vector) - -/**************************************************************************************************/ -/**************************************************************************************************/ - -#endif diff --git a/adobe/vector_fwd.hpp b/adobe/vector_fwd.hpp deleted file mode 100644 index 2bd6fd7e..00000000 --- a/adobe/vector_fwd.hpp +++ /dev/null @@ -1,37 +0,0 @@ -/* - Copyright 2013 Adobe - Distributed under the Boost Software License, Version 1.0. - (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -*/ -/**************************************************************************************************/ - -#error Deprecated -#ifndef ADOBE_VECTOR_FWD_HPP -#define ADOBE_VECTOR_FWD_HPP - -/**************************************************************************************************/ - -#include -#include - -/**************************************************************************************************/ - -namespace adobe { -inline namespace version_1 { - -/**************************************************************************************************/ - -template > -class vector; - -/**************************************************************************************************/ - -} // namespace version_1 - -using version_1::vector; - -} // namespace adobe - -#endif - -/**************************************************************************************************/ diff --git a/test/md5/main.cpp b/test/md5/main.cpp index a2e1a762..09ac0501 100644 --- a/test/md5/main.cpp +++ b/test/md5/main.cpp @@ -6,13 +6,13 @@ /**************************************************************************************************/ #include +#include #include #include #include #include -#include #include /**************************************************************************************************/ @@ -33,7 +33,7 @@ int main(int argc, char* argv[]) { try { adobe::md5_t m; - boost::filesystem::path file_path(argv[1], boost::filesystem::native); + std::filesystem::path file_path(argv[1], std::filesystem::path::native); std::ifstream stream(file_path.native_file_string().c_str(), std::ios::binary | std::ios::in); diff --git a/test/name_hash/main.cpp b/test/name_hash/main.cpp index 7e31dab8..f21cc0aa 100644 --- a/test/name_hash/main.cpp +++ b/test/name_hash/main.cpp @@ -91,7 +91,7 @@ const std::vector& zuid_corpus() { /**************************************************************************************************/ -std::vector word_corpus_init(boost::filesystem::ifstream& stream) { +std::vector word_corpus_init(std::filesystem::ifstream& stream) { std::vector result; while (stream) { @@ -107,7 +107,7 @@ std::vector word_corpus_init(boost::filesystem::ifstream& stream) /**************************************************************************************************/ -const std::vector& word_corpus(boost::filesystem::ifstream& stream) { +const std::vector& word_corpus(std::filesystem::ifstream& stream) { static std::vector result_s(word_corpus_init(stream)); return result_s; @@ -179,7 +179,7 @@ void hash_test_corpus(const std::vector& corpus, const char* corp /**************************************************************************************************/ -void hash_test(boost::filesystem::ifstream&& corpus_file) { +void hash_test(std::filesystem::ifstream&& corpus_file) { hash_test_corpus(lexed_number_corpus(), "lexed numbers"); hash_test_corpus(zuid_corpus(), "zuids"); @@ -196,12 +196,12 @@ void hash_test(boost::filesystem::ifstream&& corpus_file) { /**************************************************************************************************/ int main(int argc, char** argv) try { - boost::filesystem::path corpus_file; + std::filesystem::path corpus_file; if (argc > 1) - corpus_file = boost::filesystem::path(argv[1]); + corpus_file = std::filesystem::path(argv[1]); - hash_test(boost::filesystem::ifstream(corpus_file)); + hash_test(std::filesystem::ifstream(corpus_file)); return 0; } catch (std::exception& error) { diff --git a/test/sudoku/main.cpp b/test/sudoku/main.cpp index 53506c2d..7949f0bd 100644 --- a/test/sudoku/main.cpp +++ b/test/sudoku/main.cpp @@ -8,9 +8,6 @@ #include #include -#include -#include - #include "sudoku.hpp" #include "sudoku_utilities.hpp" @@ -23,12 +20,6 @@ #include #include -/**************************************************************************************************/ - -namespace bfs = boost::filesystem; - -/**************************************************************************************************/ - namespace { /**************************************************************************************************/ @@ -48,7 +39,7 @@ class application_t { setting_set_size }; - explicit application_t(bfs::path prefs_path) : prefs_path_m(prefs_path) { + explicit application_t(std::filesystem::path prefs_path) : prefs_path_m(prefs_path) { for (std::size_t i(0); i < setting_set_size; ++i) solver_usage_m[i] = true; @@ -70,7 +61,7 @@ class application_t { void pick_new_puzzle(); - bfs::path prefs_path_m; + std::path prefs_path_m; sudoku_set_t sudoku_set_m; sudoku::sudoku_t puzzle_m; std::array solver_usage_m; @@ -80,7 +71,7 @@ class application_t { void application_t::import_preferences() { char buffer[1024]; - bfs::ifstream input(prefs_path_m, std::ios_base::in | std::ios_base::binary); + std::ifstream input(prefs_path_m, std::ios_base::in | std::ios_base::binary); if (input.fail()) { std::cerr << "Could not open preferences file." << std::endl; @@ -386,7 +377,7 @@ int main(int argc, char** argv) { if (argc > 1) db_name.assign(argv[1]); - bfs::path filepath(db_name.c_str(), argc > 1 ? bfs::native : bfs::portable_name); + std::path filepath(db_name.c_str(), argc > 1 ? std::native : std::portable_name); { application_t(filepath).run(); } diff --git a/test/sudoku/sudoku.hpp b/test/sudoku/sudoku.hpp index c3292f85..40efff5e 100644 --- a/test/sudoku/sudoku.hpp +++ b/test/sudoku/sudoku.hpp @@ -20,12 +20,6 @@ #include #include -/**************************************************************************************************/ - -namespace bfs = boost::filesystem; - -/**************************************************************************************************/ - namespace sudoku { /**************************************************************************************************/