#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";
const char * e2 = NULL
) 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 ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW override ;
+ virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW override ;
};
}// namespace archive
basic_text_iarchive(unsigned int flags) :
detail::common_iarchive<Archive>(flags)
{}
- ~basic_text_iarchive(){}
+ ~basic_text_iarchive() override{}
};
} // namespace archive
detail::common_oarchive<Archive>(flags),
delimiter(none)
{}
- ~basic_text_oarchive(){}
+ ~basic_text_oarchive() override{}
};
} // namespace archive
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_iarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
- ~basic_xml_iarchive();
+ ~basic_xml_iarchive() override;
};
} // namespace archive
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_oarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
- ~basic_xml_oarchive();
+ ~basic_xml_oarchive() 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:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
{}
- virtual ~codecvt_null(){};
+ virtual ~codecvt_null() override{};
};
template<>
char * first2,
char * last2,
char * & next2
- ) const;
+ ) const override;
virtual BOOST_WARCHIVE_DECL 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:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
{}
- virtual ~codecvt_null(){};
+ virtual ~codecvt_null() override{};
};
} // namespace archive
{
friend class interface_iarchive<Archive>;
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>;
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));
}
protected:
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 ~iserializer() override{};
};
#ifdef BOOST_MSVC
public basic_pointer_iserializer
{
private:
- virtual void * heap_allocation() const {
+ virtual void * heap_allocation() const override {
detail::heap_allocation<T> h;
T * t = h.get();
h.release();
return t;
}
- virtual const basic_iserializer & get_basic_serializer() const {
+ virtual const basic_iserializer & get_basic_serializer() const override {
return boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance();
basic_iarchive & ar,
void * x,
const unsigned int file_version
- ) const BOOST_USED;
+ ) const override BOOST_USED;
protected:
// this should alway be a singleton so make the constructor protected
pointer_iserializer();
- ~pointer_iserializer();
+ ~pointer_iserializer() override;
};
#ifdef BOOST_MSVC
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(){}
+ virtual ~oserializer() override{}
};
#ifdef BOOST_MSVC
{
private:
const basic_oserializer &
- get_basic_serializer() const {
+ get_basic_serializer() const override {
return boost::serialization::singleton<
oserializer<Archive, T>
>::get_const_instance();
virtual BOOST_DLLEXPORT void save_object_ptr(
basic_oarchive & ar,
const void * x
- ) const BOOST_USED;
+ ) const override BOOST_USED;
public:
pointer_oserializer();
- ~pointer_oserializer();
+ ~pointer_oserializer() override;
};
#ifdef BOOST_MSVC
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){
public polymorphic_iarchive_impl
{
public:
- virtual ~polymorphic_iarchive(){};
+ virtual ~polymorphic_iarchive() override{};
};
} // namespace archive
public polymorphic_oarchive_impl
{
public:
- virtual ~polymorphic_oarchive(){};
+ virtual ~polymorphic_oarchive() override{};
};
} // namespace archive
text_iarchive_impl(std::istream & is, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
- ~text_iarchive_impl(){};
+ ~text_iarchive_impl() override{};
};
} // namespace archive
// note: added _ to suppress useless gcc warning
text_iarchive_impl<text_iarchive>(is_, flags)
{}
- ~text_iarchive(){}
+ ~text_iarchive() override{}
};
} // namespace archive
text_oarchive_impl(std::ostream & os, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
- ~text_oarchive_impl(){};
+ ~text_oarchive_impl() override{};
public:
BOOST_ARCHIVE_DECL void
save_binary(const void *address, std::size_t count);
// note: added _ to suppress useless gcc warning
text_oarchive_impl<text_oarchive>(os_, flags)
{}
- ~text_oarchive(){}
+ ~text_oarchive() override{}
};
} // namespace archive
}
BOOST_WARCHIVE_DECL
text_wiarchive_impl(std::wistream & is, unsigned int flags);
- ~text_wiarchive_impl(){};
+ ~text_wiarchive_impl() override{};
};
} // namespace archive
text_wiarchive(std::wistream & is, unsigned int flags = 0) :
text_wiarchive_impl<text_wiarchive>(is, flags)
{}
- ~text_wiarchive(){}
+ ~text_wiarchive() override{}
};
} // namespace archive
text_woarchive(std::wostream & os, unsigned int flags = 0) :
text_woarchive_impl<text_woarchive>(os, flags)
{}
- ~text_woarchive(){}
+ ~text_woarchive() override{}
};
} // namespace archive
const char * e2 = NULL
);
BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
- virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+ virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW override ;
};
}// namespace archive
BOOST_ARCHIVE_DECL
xml_iarchive_impl(std::istream & is, unsigned int flags);
BOOST_ARCHIVE_DECL
- ~xml_iarchive_impl();
+ ~xml_iarchive_impl() override;
};
} // namespace archive
xml_iarchive(std::istream & is, unsigned int flags = 0) :
xml_iarchive_impl<xml_iarchive>(is, flags)
{}
- ~xml_iarchive(){};
+ ~xml_iarchive() override{};
};
} // namespace archive
BOOST_ARCHIVE_DECL
xml_oarchive_impl(std::ostream & os, unsigned int flags);
BOOST_ARCHIVE_DECL
- ~xml_oarchive_impl();
+ ~xml_oarchive_impl() override;
public:
BOOST_ARCHIVE_DECL
void save_binary(const void *address, std::size_t count);
xml_oarchive(std::ostream & os, unsigned int flags = 0) :
xml_oarchive_impl<xml_oarchive>(os, flags)
{}
- ~xml_oarchive(){}
+ ~xml_oarchive() override{}
};
} // namespace archive
BOOST_WARCHIVE_DECL
xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
BOOST_WARCHIVE_DECL
- ~xml_wiarchive_impl();
+ ~xml_wiarchive_impl() override;
};
} // namespace archive
xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
xml_wiarchive_impl<xml_wiarchive>(is, flags)
{}
- ~xml_wiarchive(){}
+ ~xml_wiarchive() override{}
};
} // namespace archive
BOOST_WARCHIVE_DECL
xml_woarchive_impl(std::wostream & os, unsigned int flags);
BOOST_WARCHIVE_DECL
- ~xml_woarchive_impl();
+ ~xml_woarchive_impl() override;
public:
BOOST_WARCHIVE_DECL void
save_binary(const void *address, std::size_t count);
xml_woarchive(std::wostream & os, unsigned int flags = 0) :
xml_woarchive_impl<xml_woarchive>(os, flags)
{}
- ~xml_woarchive(){}
+ ~xml_woarchive() override{}
};
} // namespace archive
{
public:
BOOST_UTF8_DECL explicit utf8_codecvt_facet(std::size_t no_locale_manage=0);
- virtual ~utf8_codecvt_facet(){}
+ virtual ~utf8_codecvt_facet() override{}
protected:
BOOST_UTF8_DECL virtual std::codecvt_base::result do_in(
std::mbstate_t& state,
wchar_t * to,
wchar_t * to_end,
wchar_t*& to_next
- ) const;
+ ) const override;
BOOST_UTF8_DECL 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.
BOOST_UTF8_DECL 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_end,
std::size_t max_limit
) 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";
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 std::type_info& component_type() const { return typeid(T); }
- void* component_impl() { return component(); }
+ void set_next(streambuf_type* next) override;
+ void close_impl(BOOST_IOS::openmode m) override;
+ const std::type_info& component_type() const override { return 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_;
};
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
public:
stream_buffer() { }
- ~stream_buffer()
+ ~stream_buffer() override
{
try {
if (this->is_open() && this->auto_close())
#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";
}
- virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW
+ virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW override
{}
#ifndef BOOST_NO_TYPEID
{
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"; }
};
{
}
- ~file_parser_error() throw()
+ ~file_parser_error() throw() override
// gcc 3.4.2 complains about lack of throw specifier on compiler
// generated dtor
{
//! 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;
}
/// @param what The message to associate with this error.
ptree_error(const std::string &what);
- ~ptree_error() throw();
+ ~ptree_error() throw() override;
};
template<class T> ptree_bad_data(const std::string &what,
const T &data);
- ~ptree_bad_data() throw();
+ ~ptree_bad_data() throw() override;
/// Retrieve the data associated with this error. This is the source
/// value that failed to be translated. You need to explicitly
template<class T> ptree_bad_path(const std::string &what,
const T &path);
- ~ptree_bad_path() throw();
+ ~ptree_bad_path() throw() override;
/// Retrieve the invalid path. You need to explicitly specify the
/// type of path.
{
protected:
BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key);
- BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0();
+ BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0() override;
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
{
key_register();
}
- ~extended_type_info_no_rtti(){
+ ~extended_type_info_no_rtti() override{
key_unregister();
}
const extended_type_info *
const char * get_key() const{
return action<guid_defined< T >::value >::invoke();
}
- virtual const char * get_debug_info() const{
+ virtual const char * get_debug_info() const override{
return action<guid_defined< T >::value >::invoke();
}
- 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)
);
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();
protected:
const std::type_info * m_ti;
BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);
- BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0();
+ BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0() override;
BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);
BOOST_SERIALIZATION_DECL void type_unregister();
BOOST_SERIALIZATION_DECL const extended_type_info *
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;
}
type_register(typeid(T));
key_register();
}
- ~extended_type_info_typeid(){
+ ~extended_type_info_typeid() override{
key_unregister();
type_unregister();
}
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)
);
{
public:
static bool m_is_destroyed;
- ~singleton_wrapper(){
+ ~singleton_wrapper() {
m_is_destroyed = true;
}
};
class BOOST_SYMBOL_VISIBLE void_caster_primitive :
public void_caster
{
- virtual void const * downcast(void const * const t) const {
+ virtual void const * downcast(void const * const t) const override {
const Derived * d =
boost::serialization::smart_cast<const Derived *, const Base *>(
static_cast<const Base *>(t)
);
return d;
}
- virtual void const * upcast(void const * const t) const {
+ virtual void const * upcast(void const * const t) const override {
const Base * b =
boost::serialization::smart_cast<const Base *, const Derived *>(
static_cast<const Derived *>(t)
);
return b;
}
- virtual bool has_virtual_base() const {
+ virtual bool has_virtual_base() const override {
return false;
}
public:
void_caster_primitive();
- virtual ~void_caster_primitive();
+ virtual ~void_caster_primitive() override;
};
template <class Derived, class Base>
class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
public void_caster
{
- virtual bool has_virtual_base() const {
+ virtual bool has_virtual_base() const override {
return true;
}
public:
- virtual void const * downcast(void const * const t) const {
+ virtual void const * downcast(void const * const t) const override {
const Derived * d =
dynamic_cast<const Derived *>(
static_cast<const Base *>(t)
);
return d;
}
- virtual void const * upcast(void const * const t) const {
+ virtual void const * upcast(void const * const t) const override {
const Base * b =
dynamic_cast<const Base *>(
static_cast<const Derived *>(t)
return b;
}
void_caster_virtual_base();
- virtual ~void_caster_virtual_base();
+ virtual ~void_caster_virtual_base() override;
};
#ifdef BOOST_MSVC
m_slot(new SlotType(slot_in)), _mutex(signal_mutex)
{
}
- virtual ~connection_body() {}
- virtual bool connected() const
+ virtual ~connection_body() override {}
+ 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;
public:
foreign_shared_ptr_impl(const FSP &p): _p(p)
{}
- virtual foreign_shared_ptr_impl * clone() const
+ virtual foreign_shared_ptr_impl * clone() const override
{
return new foreign_shared_ptr_impl(*this);
}
public:
foreign_weak_ptr_impl(const FWP &p): _p(p)
{}
- virtual foreign_void_shared_ptr lock() const
+ virtual foreign_void_shared_ptr lock() const override
{
return foreign_void_shared_ptr(_p.lock());
}
- virtual bool expired() const
+ virtual bool expired() const override
{
return _p.expired();
}
- virtual foreign_weak_ptr_impl * clone() const
+ virtual foreign_weak_ptr_impl * clone() const override
{
return new foreign_weak_ptr_impl(*this);
}
const group_compare_type &group_compare = group_compare_type()):
_pimpl(new impl_class(combiner_arg, group_compare))
{};
- virtual ~BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)()
+ virtual ~BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)() override
{
}
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 throw()
+ virtual char const * what() const throw() override
{
return "tr1::bad_weak_ptr";
}
: allocator(allocator_) {
}
- virtual void dispose() {
+ virtual void dispose() override {
allocator();
}
- virtual void destroy() {
+ virtual void destroy() override {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef typename std::allocator_traits<A>::
template rebind_alloc<Y> YA;
#endif
}
- virtual void* get_deleter(const sp_typeinfo&) {
+ virtual void* get_deleter(const sp_typeinfo&) override {
return &reinterpret_cast<char&>(allocator);
}
- virtual void* get_untyped_deleter() {
+ virtual void* get_untyped_deleter() override {
return &reinterpret_cast<char&>(allocator);
}
#endif
}
- virtual void dispose() // nothrow
+ virtual void dispose() override // nothrow
{
#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 & )
+ virtual void * get_deleter( sp_typeinfo const & ) override
{
return 0;
}
- virtual void * get_untyped_deleter()
+ virtual void * get_untyped_deleter() override
{
return 0;
}
{
}
- virtual void dispose() // nothrow
+ virtual void dispose() override // nothrow
{
del( ptr );
}
- virtual void * get_deleter( sp_typeinfo const & ti )
+ virtual void * get_deleter( sp_typeinfo const & ti ) override
{
return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
}
- virtual void * get_untyped_deleter()
+ virtual void * get_untyped_deleter() override
{
return &reinterpret_cast<char&>( del );
}
{
}
- virtual void dispose() // nothrow
+ virtual void dispose() override // nothrow
{
d_( p_ );
}
- virtual void destroy() // nothrow
+ virtual void destroy() override // nothrow
{
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
a2.deallocate( this, 1 );
}
- virtual void * get_deleter( sp_typeinfo const & ti )
+ virtual void * get_deleter( sp_typeinfo const & ti ) override
{
return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
}
- virtual void * get_untyped_deleter()
+ virtual void * get_untyped_deleter() override
{
return &reinterpret_cast<char&>( d_ );
}
struct concrete_parser : abstract_parser<ScannerT, AttrT>
{
concrete_parser(ParserT const& p_) : p(p_) {}
- virtual ~concrete_parser() {}
+ virtual ~concrete_parser() override {}
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:
generic_error_category(){}
- const char * name() const BOOST_SYSTEM_NOEXCEPT;
- std::string message( int ev ) const;
+ const char * name() const BOOST_SYSTEM_NOEXCEPT override;
+ std::string message( int ev ) const override;
};
class system_error_category : public error_category
{
public:
system_error_category(){}
- const char * name() const BOOST_SYSTEM_NOEXCEPT;
- std::string message( int ev ) const;
- error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
+ const char * name() const BOOST_SYSTEM_NOEXCEPT override;
+ std::string message( int ev ) const override;
+ error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT override;
};
// generic_error_category implementation ---------------------------------//
{
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";
class bosarg :
public basic_oserializer
{
- bool class_info() const {
+ bool class_info() const override {
BOOST_ASSERT(false);
return false;
}
// returns true if objects should be tracked
- bool tracking(const unsigned int) const {
+ bool tracking(const unsigned int) const override {
BOOST_ASSERT(false);
return false;
}
// returns class version
- version_type version() const {
+ version_type version() const override {
BOOST_ASSERT(false);
return version_type(0);
}
// returns true if this class is polymorphic
- bool is_polymorphic() const{
+ bool is_polymorphic() const override{
BOOST_ASSERT(false);
return false;
}
void save_object_data(
basic_oarchive & /*ar*/, const void * /*x*/
- ) const {
+ ) const override {
BOOST_ASSERT(false);
}
public:
class extended_type_info_arg : public extended_type_info
{
virtual bool
- is_less_than(const extended_type_info & /*rhs*/) const {
+ is_less_than(const extended_type_info & /*rhs*/) const override {
BOOST_ASSERT(false);
return false;
};
virtual bool
- is_equal(const extended_type_info & /*rhs*/) const {
+ is_equal(const extended_type_info & /*rhs*/) const override {
BOOST_ASSERT(false);
return false;
};
- virtual const char * get_debug_info() const {
+ virtual const char * get_debug_info() const override {
return get_key();
}
- virtual void * construct(unsigned int /*count*/, ...) const{
+ virtual void * construct(unsigned int /*count*/, ...) const override{
BOOST_ASSERT(false);
return NULL;
}
- virtual void destroy(void const * const /*p*/) const {
+ virtual void destroy(void const * const /*p*/) const override {
BOOST_ASSERT(false);
}
public:
extended_type_info(0, key)
{}
- ~extended_type_info_arg(){
+ ~extended_type_info_arg() override{
}
};
class extended_type_info_typeid_arg :
public extended_type_info_typeid_0
{
- virtual void * construct(unsigned int /*count*/, ...) const{
+ virtual void * construct(unsigned int /*count*/, ...) const override{
BOOST_ASSERT(false);
return NULL;
}
- virtual void destroy(void const * const /*p*/) const {
+ virtual void destroy(void const * const /*p*/) const override {
BOOST_ASSERT(false);
}
public:
// be added to the map.
m_ti = & ti;
}
- ~extended_type_info_typeid_arg(){
+ ~extended_type_info_typeid_arg() override{
m_ti = NULL;
}
};
void const * const t
) const;
virtual void const *
- upcast(void const * const t) const{
+ upcast(void const * const t) const override{
if(m_includes_virtual_base)
return vbc_upcast(t);
return static_cast<const char *> ( t ) - m_difference;
}
virtual void const *
- downcast(void const * const t) const{
+ downcast(void const * const t) const override{
if(m_includes_virtual_base)
return vbc_downcast(t);
return static_cast<const char *> ( t ) + m_difference;
virtual bool is_shortcut() const {
return true;
}
- virtual bool has_virtual_base() const {
+ virtual bool has_virtual_base() const override {
return m_includes_virtual_base;
}
public:
{
recursive_register(includes_virtual_base);
}
- virtual ~void_caster_shortcut(){
+ virtual ~void_caster_shortcut() override{
recursive_unregister();
}
};
class void_caster_argument : public void_caster
{
virtual void const *
- upcast(void const * const /*t*/) const {
+ upcast(void const * const /*t*/) const override {
BOOST_ASSERT(false);
return NULL;
}
virtual void const *
- downcast( void const * const /*t*/) const {
+ downcast( void const * const /*t*/) const override {
BOOST_ASSERT(false);
return NULL;
}
- virtual bool has_virtual_base() const {
+ virtual bool has_virtual_base() const override {
BOOST_ASSERT(false);
return false;
}
) :
void_caster(derived, base)
{}
- virtual ~void_caster_argument(){};
+ virtual ~void_caster_argument() override{};
};
#ifdef BOOST_MSVC
projects / dealii.git / commitdiff