#endif
public: // queries
- virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
+ virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT override
{
return boost::typeindex::type_id<ValueType>().type_info();
}
- virtual placeholder * clone() const
+ virtual placeholder * clone() const override
{
return new holder(held);
}
#endif
{
public:
- virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+ virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW override
{
return "boost::bad_any_cast: "
"failed conversion using boost::any_cast";
) BOOST_NOEXCEPT;
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
- virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
+ virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW override ;
};
}// namespace archive
template<>
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
{
- virtual bool do_always_noconv() const throw() {
+ virtual bool do_always_noconv() const throw() override {
return true;
}
public:
char * first2,
char * last2,
char * & next2
- ) const;
+ ) const override;
virtual std::codecvt_base::result
do_in(
std::mbstate_t & state,
wchar_t * first2,
wchar_t * last2,
wchar_t * & next2
- ) const;
- virtual int do_encoding( ) const throw( ){
+ ) const override;
+ virtual int do_encoding( ) const throw( ) override{
return sizeof(wchar_t) / sizeof(char);
}
- virtual int do_max_length( ) const throw( ){
+ virtual int do_max_length( ) const throw( ) override{
return do_encoding();
}
public:
friend class interface_iarchive<Archive>;
friend class basic_iarchive;
private:
- virtual void vload(version_type & t){
+ virtual void vload(version_type & t) override{
* this->This() >> t;
}
- virtual void vload(object_id_type & t){
+ virtual void vload(object_id_type & t) override{
* this->This() >> t;
}
- virtual void vload(class_id_type & t){
+ virtual void vload(class_id_type & t) override{
* this->This() >> t;
}
- virtual void vload(class_id_optional_type & t){
+ virtual void vload(class_id_optional_type & t) override{
* this->This() >> t;
}
- virtual void vload(tracking_type & t){
+ virtual void vload(tracking_type & t) override{
* this->This() >> t;
}
- virtual void vload(class_name_type &s){
+ virtual void vload(class_name_type &s) override{
* this->This() >> s;
}
protected:
friend class interface_oarchive<Archive>;
friend class basic_oarchive;
private:
- virtual void vsave(const version_type t){
+ virtual void vsave(const version_type t) override{
* this->This() << t;
}
- virtual void vsave(const object_id_type t){
+ virtual void vsave(const object_id_type t) override{
* this->This() << t;
}
- virtual void vsave(const object_reference_type t){
+ virtual void vsave(const object_reference_type t) override{
* this->This() << t;
}
- virtual void vsave(const class_id_type t){
+ virtual void vsave(const class_id_type t) override{
* this->This() << t;
}
- virtual void vsave(const class_id_reference_type t){
+ virtual void vsave(const class_id_reference_type t) override{
* this->This() << t;
}
- virtual void vsave(const class_id_optional_type t){
+ virtual void vsave(const class_id_optional_type t) override{
* this->This() << t;
}
- virtual void vsave(const class_name_type & t){
+ virtual void vsave(const class_name_type & t) override{
* this->This() << t;
}
- virtual void vsave(const tracking_type t){
+ virtual void vsave(const tracking_type t) override{
* this->This() << t;
}
protected:
class iserializer : public basic_iserializer
{
private:
- virtual void destroy(/*const*/ void *address) const {
+ virtual void destroy(/*const*/ void *address) const override{
boost::serialization::access::destroy(static_cast<T *>(address));
}
public:
basic_iarchive & ar,
void *x,
const unsigned int file_version
- ) const BOOST_USED;
- virtual bool class_info() const {
+ ) const override BOOST_USED;
+ virtual bool class_info() const override {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
- virtual bool tracking(const unsigned int /* flags */) const {
+ virtual bool tracking(const unsigned int /* flags */) const override {
return boost::serialization::tracking_level< T >::value
== boost::serialization::track_always
|| ( boost::serialization::tracking_level< T >::value
== boost::serialization::track_selectively
&& serialized_as_pointer());
}
- virtual version_type version() const {
+ virtual version_type version() const override {
return version_type(::boost::serialization::version< T >::value);
}
- virtual bool is_polymorphic() const {
+ virtual bool is_polymorphic() const override {
return boost::is_polymorphic< T >::value;
}
virtual ~iserializer(){};
virtual BOOST_DLLEXPORT void save_object_data(
basic_oarchive & ar,
const void *x
- ) const BOOST_USED;
- virtual bool class_info() const {
+ ) const override BOOST_USED;
+ virtual bool class_info() const override {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
- virtual bool tracking(const unsigned int /* flags */) const {
+ virtual bool tracking(const unsigned int /* flags */) const override {
return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
|| (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
&& serialized_as_pointer());
}
- virtual version_type version() const {
+ virtual version_type version() const override {
return version_type(::boost::serialization::version< T >::value);
}
- virtual bool is_polymorphic() const {
+ virtual bool is_polymorphic() const override {
return boost::is_polymorphic< T >::value;
}
virtual ~oserializer(){}
dataflow_exception(exception_code c = other_exception) : code(c)
{}
- virtual const char *what( ) const throw( )
+ virtual const char *what( ) const throw( ) override
{
const char *msg = "unknown exception code";
switch(code){
// Marking those functions with `inline` suppresses the warnings.
// There must be no harm from marking virtual functions as inline: inline virtual
// call can be inlined ONLY when the compiler knows the "exact class".
- inline base_type* setbuf(char_type* s, streamsize n);
- inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
- inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
+ inline base_type* setbuf(char_type* s, streamsize n) override;
+ inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) override;
+ inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) override;
private:
basic_pointerbuf& operator=(const basic_pointerbuf&);
wchar_t * to,
wchar_t * to_end,
wchar_t*& to_next
- ) const;
+ ) const override;
virtual std::codecvt_base::result do_out(
std::mbstate_t & state,
char * to,
char * to_end,
char * & to_next
- ) const;
+ ) const override;
bool invalid_continuing_octet(unsigned char octet_1) const {
return (octet_1 < 0x80|| 0xbf< octet_1);
// == total octets - 1.
int get_cont_octet_out_count(wchar_t word) const ;
- virtual bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW {
+ virtual bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW override {
return false;
}
char * from,
char * /*to*/,
char * & next
- ) const {
+ ) const override {
next = from;
return ok;
}
- virtual int do_encoding() const BOOST_NOEXCEPT_OR_NOTHROW {
+ virtual int do_encoding() const BOOST_NOEXCEPT_OR_NOTHROW override {
const int variable_byte_external_encoding=0;
return variable_byte_external_encoding;
}
const char * from,
const char * from_end,
std::size_t max_limit
- ) const
+ ) const override
#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
throw()
#endif
}
// Largest possible value do_length(state,from,from_end,1) could return.
- virtual int do_max_length() const BOOST_NOEXCEPT_OR_NOTHROW {
+ virtual int do_max_length() const BOOST_NOEXCEPT_OR_NOTHROW override {
return 6; // largest UTF-8 encoding of a UCS-4 character
}
};
{
public:
format_error() {}
- virtual const char *what() const throw() {
+ virtual const char *what() const throw() override {
return "boost::format_error: "
"format generic failure";
}
: pos_(pos), next_(size) {}
std::size_t get_pos() const { return pos_; }
std::size_t get_next() const { return next_; }
- virtual const char *what() const throw() {
+ virtual const char *what() const throw() override {
return "boost::bad_format_string: format-string is ill-formed";
}
};
: cur_(cur), expected_(expected) {}
std::size_t get_cur() const { return cur_; }
std::size_t get_expected() const { return expected_; }
- virtual const char *what() const throw() {
+ virtual const char *what() const throw() override {
return "boost::too_few_args: "
"format-string referred to more arguments than were passed";
}
: cur_(cur), expected_(expected) {}
std::size_t get_cur() const { return cur_; }
std::size_t get_expected() const { return expected_; }
- virtual const char *what() const throw() {
+ virtual const char *what() const throw() override {
return "boost::too_many_args: "
"format-string referred to fewer arguments than were passed";
}
int get_index() const { return index_; }
int get_beg() const { return beg_; }
int get_end() const { return end_; }
- virtual const char *what() const throw() {
+ virtual const char *what() const throw() override {
return "boost::out_of_range: "
"tried to refer to an argument (or item) number which"
" is out of range, according to the format string";
\brief Returns the explanatory string.
\return Pointer to a null-terminated string with explanatory information.
*/
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Centroid calculation exception";
}
inline overlay_invalid_input_exception() {}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Overlay invalid input exception";
}
virtual ~turn_info_exception() throw()
{}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return message.c_str();
}
virtual ~inconsistent_turns_exception() throw()
{}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Inconsistent Turns exception";
}
class exception : public std::exception
{
public:
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry exception";
}
inline invalid_input_exception() {}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Invalid-Input exception";
}
inline empty_input_exception() {}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Empty-Input exception";
}
inline invalid_output_exception() {}
- virtual char const* what() const throw()
+ virtual char const* what() const throw() override
{
return "Boost.Geometry Invalid-Output exception";
}
virtual ~read_wkt_exception() throw() {}
- virtual const char* what() const throw()
+ virtual const char* what() const throw() override
{
return complete.c_str();
}
void open(const T& t BOOST_IOSTREAMS_PUSH_PARAMS());
bool is_open() const;
void close();
- bool auto_close() const;
- void set_auto_close(bool close);
- bool strict_sync();
+ bool auto_close() const override;
+ void set_auto_close(bool close) override;
+ bool strict_sync() override;
// Declared in linked_streambuf.
T* component() { return &*obj(); }
//----------virtual functions---------------------------------------------//
#ifndef BOOST_IOSTREAMS_NO_LOCALE
- void imbue(const std::locale& loc);
+ void imbue(const std::locale& loc) override;
#endif
#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
public:
#endif
- int_type underflow();
- int_type pbackfail(int_type c);
- int_type overflow(int_type c);
- int sync();
+ int_type underflow() override;
+ int_type pbackfail(int_type c) override;
+ int_type overflow(int_type c) override;
+ int sync() override;
pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
- BOOST_IOS::openmode which );
- pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
+ BOOST_IOS::openmode which ) override;
+ pos_type seekpos(pos_type sp, BOOST_IOS::openmode which) override;
// Declared in linked_streambuf.
- void set_next(streambuf_type* next);
- void close_impl(BOOST_IOS::openmode m);
- const boost::core::typeinfo& component_type() const { return BOOST_CORE_TYPEID(T); }
- void* component_impl() { return component(); }
+ void set_next(streambuf_type* next) override;
+ void close_impl(BOOST_IOS::openmode m) override;
+ const boost::core::typeinfo& component_type() const override { return BOOST_CORE_TYPEID(T); }
+ void* component_impl() override { return component(); }
private:
//----------Accessor functions--------------------------------------------//
>::stream_type stream_type;
filtering_stream_base() : stream_type(0) { this->set_chain(&chain_); }
private:
- void notify() { this->rdbuf(chain_.empty() ? 0 : &chain_.front()); }
+ void notify() override { this->rdbuf(chain_.empty() ? 0 : &chain_.front()); }
Chain chain_;
};
#endif
{}
- virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW {
+ virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW override{
return "bad lexical cast: "
"source type value could not be interpreted as target";
}
{
public:
- virtual const char * what() const throw()
+ virtual const char * what() const throw() override
{ return "bad numeric conversion: overflow"; }
};
{
public:
- virtual const char * what() const throw()
+ virtual const char * what() const throw() override
{ return "bad numeric conversion: negative overflow"; }
};
class positive_overflow : public bad_numeric_cast
{
public:
- virtual const char * what() const throw()
+ virtual const char * what() const throw() override
{ return "bad numeric conversion: positive overflow"; }
};
//! Gets human readable description of error.
//! \return Pointer to null terminated description of the error.
- virtual const char *what() const throw()
+ virtual const char *what() const throw() override
{
return m_what;
}
virtual std::exception
{
char const *
- what() const throw()
+ what() const throw() override
{
return "Boost QVM error";
}
BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0();
public:
virtual BOOST_SERIALIZATION_DECL bool
- is_less_than(const boost::serialization::extended_type_info &rhs) const ;
+ is_less_than(const boost::serialization::extended_type_info &rhs) const override;
virtual BOOST_SERIALIZATION_DECL bool
- is_equal(const boost::serialization::extended_type_info &rhs) const ;
+ is_equal(const boost::serialization::extended_type_info &rhs) const override;
};
} // no_rtti_system
class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
public extended_type_info
{
- virtual const char * get_debug_info() const {
+ virtual const char * get_debug_info() const override{
if(static_cast<const std::type_info *>(0) == m_ti)
return static_cast<const char *>(0);
return m_ti->name();
get_extended_type_info(const std::type_info & ti) const;
public:
virtual BOOST_SERIALIZATION_DECL bool
- is_less_than(const extended_type_info &rhs) const;
+ is_less_than(const extended_type_info &rhs) const override;
virtual BOOST_SERIALIZATION_DECL bool
- is_equal(const extended_type_info &rhs) const;
+ is_equal(const extended_type_info &rhs) const override;
const std::type_info & get_typeid() const {
return *m_ti;
}
const char * get_key() const {
return boost::serialization::guid< T >();
}
- virtual void * construct(unsigned int count, ...) const{
+ virtual void * construct(unsigned int count, ...) const override{
// count up the arguments
std::va_list ap;
va_start(ap, count);
return NULL;
}
}
- virtual void destroy(void const * const p) const {
+ virtual void destroy(void const * const p) const override{
boost::serialization::access::destroy(
static_cast<T const *>(p)
);
{
}
virtual ~connection_body() {}
- virtual bool connected() const
+ virtual bool connected() const override
{
garbage_collecting_lock<mutex_type> local_lock(*_mutex);
nolock_grab_tracked_objects(local_lock, detail::null_output_iterator());
}
}
// expose Lockable concept of mutex
- virtual void lock()
+ virtual void lock() override
{
_mutex->lock();
}
- virtual void unlock()
+ virtual void unlock() override
{
_mutex->unlock();
}
return *m_slot;
}
protected:
- virtual shared_ptr<void> release_slot() const
+ virtual shared_ptr<void> release_slot() const override
{
shared_ptr<void> released_slot = m_slot;
swap(_pimpl, other._pimpl);
}
protected:
- virtual shared_ptr<void> lock_pimpl() const
+ virtual shared_ptr<void> lock_pimpl() const override
{
return _pimpl;
}
class expired_slot: public bad_weak_ptr
{
public:
- virtual char const * what() const throw()
+ virtual char const * what() const throw() override
{
return "boost::signals2::expired_slot";
}
class no_slots_error: public std::exception
{
public:
- virtual const char* what() const throw() {return "boost::signals2::no_slots_error";}
+ virtual const char* what() const throw() override {return "boost::signals2::no_slots_error";}
};
template<typename T>
{
public:
- virtual char const * what() const BOOST_NOEXCEPT_OR_NOTHROW
+ virtual char const * what() const BOOST_NOEXCEPT_OR_NOTHROW override
{
return "tr1::bad_weak_ptr";
}
#endif
- virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+ virtual void local_cb_destroy() BOOST_SP_NOEXCEPT override
{
delete this;
}
- virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+ virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT override
{
return pn_;
}
shared_count pn_;
- virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+ virtual void local_cb_destroy() BOOST_SP_NOEXCEPT override
{
shared_count().swap( pn_ );
}
- virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+ virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT override
{
return pn_;
}
#endif
}
- virtual void dispose() BOOST_SP_NOEXCEPT
+ virtual void dispose() BOOST_SP_NOEXCEPT override
{
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
boost::checked_delete( px_ );
}
- virtual void * get_deleter( sp_typeinfo const & ) BOOST_SP_NOEXCEPT
+ virtual void * get_deleter( sp_typeinfo const & ) BOOST_SP_NOEXCEPT override
{
return 0;
}
- virtual void * get_local_deleter( sp_typeinfo const & ) BOOST_SP_NOEXCEPT
+ virtual void * get_local_deleter( sp_typeinfo const & ) BOOST_SP_NOEXCEPT override
{
return 0;
}
- virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT
+ virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT override
{
return 0;
}
{
}
- virtual void dispose() BOOST_SP_NOEXCEPT
+ virtual void dispose() BOOST_SP_NOEXCEPT override
{
del( ptr );
}
- virtual void * get_deleter( sp_typeinfo const & ti ) BOOST_SP_NOEXCEPT
+ virtual void * get_deleter( sp_typeinfo const & ti ) BOOST_SP_NOEXCEPT override
{
return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
}
- virtual void * get_local_deleter( sp_typeinfo const & ti ) BOOST_SP_NOEXCEPT
+ virtual void * get_local_deleter( sp_typeinfo const & ti ) BOOST_SP_NOEXCEPT override
{
return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
}
- virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT
+ virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT override
{
return &reinterpret_cast<char&>( del );
}
virtual ~concrete_parser() {}
virtual typename match_result<ScannerT, AttrT>::type
- do_parse_virtual(ScannerT const& scan) const
+ do_parse_virtual(ScannerT const& scan) const override
{
return p.parse(scan);
}
virtual abstract_parser<ScannerT, AttrT>*
- clone() const
+ clone() const override
{
return new concrete_parser(p);
}
{
public: // std::exception interface
- virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+ virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW override
{
return "boost::bad_visit: "
"failed visitation using boost::apply_visitor";
{
public: // std::exception implementation
- virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+ virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW override
{
return "boost::bad_get: "
"failed value get using boost::get";
typename Tensor<rank_1 + rank_2 - 2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- result{};
+ result;
TensorAccessors::internal::
ReorderedIndexView<0, rank_2, const Tensor<rank_2, dim, OtherNumber>>
typename Tensor<rank_1 + rank_2 - 2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- result{};
+ result;
TensorAccessors::contract<1, rank_1, rank_2, dim>(result, reord_01, reord_02);
return result;
}
typename Tensor<rank_1 + rank_2 - 4,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- result{};
+ result;
TensorAccessors::contract<2, rank_1, rank_2, dim>(result, reord_3, reord_4);
return result;
}
scalar_product(const Tensor<rank, dim, Number> & left,
const Tensor<rank, dim, OtherNumber> &right)
{
- typename ProductType<Number, OtherNumber>::type result{};
+ typename ProductType<Number, OtherNumber>::type result;
TensorAccessors::contract<rank, rank, rank, dim>(result, left, right);
return result;
}
typename Tensor<rank_1 + rank_2,
dim,
typename ProductType<Number, OtherNumber>::type>::tensor_type
- result{};
+ result;
TensorAccessors::contract<0, rank_1, rank_2, dim>(result, src1, src2);
return result;
}
projects / dealii.git / commitdiff