Pixyco-XYZ/openmesh
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

overrides

Browse Source
This commit is contained in:
Jan Möbius
2019-05-28 11:50:49 +02:00
parent 072919fafe
commit bd0901caa8
13 changed files with 111 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/OpenMesh/Core/IO/reader/OBJReader.hh
View File

@@ -87,16 +87,16 @@ public:
virtual ~_OBJReader_() { }
std::string get_description() const { return "Alias/Wavefront"; }
std::string get_extensions() const { return "obj"; }
std::string get_description() const override { return "Alias/Wavefront"; }
std::string get_extensions() const override { return "obj"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
bool read(std::istream& _in,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
private:

12
src/OpenMesh/Core/IO/reader/OFFReader.hh
View File

@@ -118,17 +118,17 @@ public:
/// Destructor
virtual ~_OFFReader_() {};
std::string get_description() const { return "Object File Format"; }
std::string get_extensions() const { return "off"; }
std::string get_magic() const { return "OFF"; }
std::string get_description() const override { return "Object File Format"; }
std::string get_extensions() const override { return "off"; }
std::string get_magic() const override { return "OFF"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
bool can_u_read(const std::string& _filename) const;
bool can_u_read(const std::string& _filename) const override;
bool read(std::istream& _in, BaseImporter& _bi, Options& _opt );
bool read(std::istream& _in, BaseImporter& _bi, Options& _opt ) override;
private:

12
src/OpenMesh/Core/IO/reader/OMReader.hh
View File

@@ -89,20 +89,20 @@ public:
_OMReader_();
virtual ~_OMReader_() { }
std::string get_description() const { return "OpenMesh File Format"; }
std::string get_extensions() const { return "om"; }
std::string get_magic() const { return "OM"; }
std::string get_description() const override { return "OpenMesh File Format"; }
std::string get_extensions() const override { return "om"; }
std::string get_magic() const override { return "OM"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt );
Options& _opt ) override;
//! Stream Reader for std::istream input in binary format
bool read(std::istream& _is,
BaseImporter& _bi,
Options& _opt );
Options& _opt ) override;
virtual bool can_u_read(const std::string& _filename) const;
virtual bool can_u_read(const std::string& _filename) const override;
virtual bool can_u_read(std::istream& _is) const;

12
src/OpenMesh/Core/IO/reader/PLYReader.hh
View File

@@ -97,19 +97,19 @@ public:
_PLYReader_();
std::string get_description() const { return "PLY polygon file format"; }
std::string get_extensions() const { return "ply"; }
std::string get_magic() const { return "PLY"; }
std::string get_description() const override { return "PLY polygon file format"; }
std::string get_extensions() const override { return "ply"; }
std::string get_magic() const override { return "PLY"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
bool read(std::istream& _is,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
bool can_u_read(const std::string& _filename) const;
bool can_u_read(const std::string& _filename) const override;
enum ValueType {
Unsupported,

8
src/OpenMesh/Core/IO/reader/STLReader.hh
View File

@@ -92,17 +92,17 @@ public:
virtual ~_STLReader_() {};
std::string get_description() const
std::string get_description() const override
{ return "Stereolithography Interface Format"; }
std::string get_extensions() const { return "stl stla stlb"; }
std::string get_extensions() const override { return "stl stla stlb"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
bool read(std::istream& _in,
BaseImporter& _bi,
Options& _opt);
Options& _opt) override;
/** Set the threshold to be used for considering two point to be equal.
Can be used to merge small gaps */

10
src/OpenMesh/Core/IO/writer/OBJWriter.hh
View File

@@ -88,14 +88,14 @@ public:
/// Destructor
virtual ~_OBJWriter_() {};
std::string get_description() const { return "Alias/Wavefront"; }
std::string get_extensions() const { return "obj"; }
std::string get_description() const override { return "Alias/Wavefront"; }
std::string get_extensions() const override { return "obj"; }
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter&, Options) const { return 0; }
size_t binary_size(BaseExporter&, Options) const override { return 0; }
private:

10
src/OpenMesh/Core/IO/writer/OFFWriter.hh
View File

@@ -97,14 +97,14 @@ public:
virtual ~_OFFWriter_() {};
std::string get_description() const { return "no description"; }
std::string get_extensions() const { return "off"; }
std::string get_description() const override { return "no description"; }
std::string get_extensions() const override { return "off"; }
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter& _be, Options _opt) const;
size_t binary_size(BaseExporter& _be, Options _opt) const override;
protected:

10
src/OpenMesh/Core/IO/writer/OMWriter.hh
View File

@@ -98,15 +98,15 @@ public:
/// Destructor
virtual ~_OMWriter_() {};
std::string get_description() const
std::string get_description() const override
{ return "OpenMesh Format"; }
std::string get_extensions() const
std::string get_extensions() const override
{ return "om"; }
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter& _be, Options _opt) const;
size_t binary_size(BaseExporter& _be, Options _opt) const override;
static OMFormat::uint8 get_version() { return version_; }
@@ -116,7 +116,7 @@ protected:
static const OMFormat::uchar magic_[3];
static const OMFormat::uint8 version_;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write_binary(std::ostream&, BaseExporter&, Options) const;

10
src/OpenMesh/Core/IO/writer/PLYWriter.hh
View File

@@ -95,14 +95,14 @@ public:
/// Destructor
virtual ~_PLYWriter_() {};
std::string get_description() const { return "PLY polygon file format"; }
std::string get_extensions() const { return "ply"; }
std::string get_description() const override { return "PLY polygon file format"; }
std::string get_extensions() const override { return "ply"; }
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter& _be, Options _opt) const;
size_t binary_size(BaseExporter& _be, Options _opt) const override;
enum ValueType {
Unsupported = 0,

10
src/OpenMesh/Core/IO/writer/STLWriter.hh
View File

@@ -88,14 +88,14 @@ public:
/// Destructor
virtual ~_STLWriter_() {};
std::string get_description() const { return "Stereolithography Format"; }
std::string get_extensions() const { return "stl stla stlb"; }
std::string get_description() const override { return "Stereolithography Format"; }
std::string get_extensions() const override { return "stl stla stlb"; }
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter&, Options) const;
size_t binary_size(BaseExporter&, Options) const override;
private:
bool write_stla(const std::string&, BaseExporter&, Options) const;

10
src/OpenMesh/Core/IO/writer/VTKWriter.hh
View File

@@ -29,13 +29,13 @@ class OPENMESHDLLEXPORT _VTKWriter_ : public BaseWriter
public:
_VTKWriter_();
std::string get_description() const { return "VTK"; }
std::string get_extensions() const { return "vtk"; }
std::string get_description() const override { return "VTK"; }
std::string get_extensions() const override { return "vtk"; }
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const;
bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const override;
size_t binary_size(BaseExporter&, Options) const { return 0; }
size_t binary_size(BaseExporter&, Options) const override { return 0; }
};
//== TYPE DEFINITION ==========================================================

80
src/OpenMesh/Core/Utils/Property.hh
View File

@@ -109,22 +109,22 @@ public:
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void clear() { data_.clear(); vector_type().swap(data_); }
virtual void push_back() { data_.push_back(T()); }
virtual void swap(size_t _i0, size_t _i1)
virtual void reserve(size_t _n) override { data_.reserve(_n); }
virtual void resize(size_t _n) override { data_.resize(_n); }
virtual void clear() override { data_.clear(); vector_type().swap(data_); }
virtual void push_back() override { data_.push_back(T()); }
virtual void swap(size_t _i0, size_t _i1) override
{ std::swap(data_[_i0], data_[_i1]); }
virtual void copy(size_t _i0, size_t _i1)
virtual void copy(size_t _i0, size_t _i1) override
{ data_[_i1] = data_[_i0]; }
public:
virtual void set_persistent( bool _yn )
virtual void set_persistent( bool _yn ) override
{ check_and_set_persistent<T>( _yn ); }
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return IO::size_of<T>(); }
virtual size_t n_elements() const override { return data_.size(); }
virtual size_t element_size() const override { return IO::size_of<T>(); }
#ifndef DOXY_IGNORE_THIS
struct plus {
@@ -133,17 +133,17 @@ public:
};
#endif
virtual size_t size_of(void) const
virtual size_t size_of(void) const override
{
if (element_size() != IO::UnknownSize)
return this->BaseProperty::size_of(n_elements());
return std::accumulate(data_.begin(), data_.end(), size_t(0), plus());
}
virtual size_t size_of(size_t _n_elem) const
virtual size_t size_of(size_t _n_elem) const override
{ return this->BaseProperty::size_of(_n_elem); }
virtual size_t store( std::ostream& _ostr, bool _swap ) const
virtual size_t store( std::ostream& _ostr, bool _swap ) const override
{
if ( IO::is_streamable<vector_type>() )
return IO::store(_ostr, data_, _swap );
@@ -153,7 +153,7 @@ public:
return bytes;
}
virtual size_t restore( std::istream& _istr, bool _swap )
virtual size_t restore( std::istream& _istr, bool _swap ) override
{
if ( IO::is_streamable<vector_type>() )
return IO::restore(_istr, data_, _swap );
@@ -199,7 +199,7 @@ public: // data access interface
}
/// Make a copy of self.
PropertyT<T>* clone() const
PropertyT<T>* clone() const override
{
PropertyT<T>* p = new PropertyT<T>( *this );
return p;
@@ -236,31 +236,31 @@ public:
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void clear() { data_.clear(); vector_type().swap(data_); }
virtual void push_back() { data_.push_back(bool()); }
virtual void swap(size_t _i0, size_t _i1)
virtual void reserve(size_t _n) override { data_.reserve(_n); }
virtual void resize(size_t _n) override { data_.resize(_n); }
virtual void clear() override { data_.clear(); vector_type().swap(data_); }
virtual void push_back() override { data_.push_back(bool()); }
virtual void swap(size_t _i0, size_t _i1) override
{ bool t(data_[_i0]); data_[_i0]=data_[_i1]; data_[_i1]=t; }
virtual void copy(size_t _i0, size_t _i1)
virtual void copy(size_t _i0, size_t _i1) override
{ data_[_i1] = data_[_i0]; }
public:
virtual void set_persistent( bool _yn )
virtual void set_persistent( bool _yn ) override
{
check_and_set_persistent<bool>( _yn );
}
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return UnknownSize; }
virtual size_t size_of() const { return size_of( n_elements() ); }
virtual size_t size_of(size_t _n_elem) const
virtual size_t n_elements() const override { return data_.size(); }
virtual size_t element_size() const override { return UnknownSize; }
virtual size_t size_of() const override { return size_of( n_elements() ); }
virtual size_t size_of(size_t _n_elem) const override
{
return _n_elem / 8 + ((_n_elem % 8)!=0);
}
size_t store( std::ostream& _ostr, bool /* _swap */ ) const
size_t store( std::ostream& _ostr, bool /* _swap */ ) const override
{
size_t bytes = 0;
@@ -299,7 +299,7 @@ public:
return bytes;
}
size_t restore( std::istream& _istr, bool /* _swap */ )
size_t restore( std::istream& _istr, bool /* _swap */ ) override
{
size_t bytes = 0;
@@ -400,34 +400,34 @@ public:
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void clear() { data_.clear(); vector_type().swap(data_); }
virtual void push_back() { data_.push_back(std::string()); }
virtual void swap(size_t _i0, size_t _i1) {
virtual void reserve(size_t _n) override { data_.reserve(_n); }
virtual void resize(size_t _n) override { data_.resize(_n); }
virtual void clear() override { data_.clear(); vector_type().swap(data_); }
virtual void push_back() override { data_.push_back(std::string()); }
virtual void swap(size_t _i0, size_t _i1) override {
std::swap(data_[_i0], data_[_i1]);
}
virtual void copy(size_t _i0, size_t _i1)
virtual void copy(size_t _i0, size_t _i1) override
{ data_[_i1] = data_[_i0]; }
public:
virtual void set_persistent( bool _yn )
virtual void set_persistent( bool _yn ) override
{ check_and_set_persistent<std::string>( _yn ); }
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return UnknownSize; }
virtual size_t size_of() const
virtual size_t n_elements() const override { return data_.size(); }
virtual size_t element_size() const override { return UnknownSize; }
virtual size_t size_of() const override
{ return IO::size_of( data_ ); }
virtual size_t size_of(size_t /* _n_elem */) const
virtual size_t size_of(size_t /* _n_elem */) const override
{ return UnknownSize; }
/// Store self as one binary block. Max. length of a string is 65535 bytes.
size_t store( std::ostream& _ostr, bool _swap ) const
size_t store( std::ostream& _ostr, bool _swap ) const override
{ return IO::store( _ostr, data_, _swap ); }
size_t restore( std::istream& _istr, bool _swap )
size_t restore( std::istream& _istr, bool _swap ) override
{ return IO::restore( _istr, data_, _swap ); }
public:

30
src/OpenMesh/Tools/Utils/Timer.cc
View File

@@ -100,11 +100,11 @@ public:
TimerImplWin32(void);
~TimerImplWin32(void) { ; }
virtual void reset(void);
virtual void start(void);
virtual void stop(void);
virtual void cont(void);
virtual double seconds(void) const;
virtual void reset(void) override;
virtual void start(void) override;
virtual void stop(void) override;
virtual void cont(void) override;
virtual double seconds(void) const override;
};
TimerImplWin32::TimerImplWin32(void)
@@ -198,10 +198,10 @@ public:
~TimerImplGToD()
{ }
virtual void reset(void) { seconds_ = 0.0; }
virtual void start(void) { seconds_ = 0.0; gettimeofday( &start_, &tz_ ); }
virtual void reset(void) override { seconds_ = 0.0; }
virtual void start(void) override { seconds_ = 0.0; gettimeofday( &start_, &tz_ ); }
virtual void stop(void)
virtual void stop(void) override
{
gettimeofday( &stop_, &tz_ );
@@ -209,9 +209,9 @@ public:
seconds_ += (double)(stop_.tv_usec- start_.tv_usec)*1e-6;
}
virtual void cont(void) { gettimeofday( &start_, &tz_); }
virtual void cont(void) override { gettimeofday( &start_, &tz_); }
virtual double seconds() const { return seconds_; }
virtual double seconds() const override { return seconds_; }
private:
@@ -234,11 +234,11 @@ public:
TimerImplStd() : freq_(clockticks),count_(0),start_(0) { reset(); }
~TimerImplStd() { ; }
virtual void reset(void) { count_ = 0; }
virtual void start(void) { count_ = 0; start_ = clock(); }
virtual void stop(void);
virtual void cont(void) { start_ = clock(); }
virtual double seconds(void) const { return (double)count_/(double)freq_; }
virtual void reset(void) override { count_ = 0; }
virtual void start(void) override { count_ = 0; start_ = clock(); }
virtual void stop(void) override;
virtual void cont(void) override { start_ = clock(); }
virtual double seconds(void) const override { return (double)count_/(double)freq_; }
protected:
unsigned long freq_;