)
load_parameters(cxx-flags)
-set_source_files_properties(${Compile.sources} ${Test.sources} PROPERTIES COMPILE_FLAGS ${Param.cxx-flags})
+load_parameters(cxx-flags-gtest)
+set_source_files_properties(${Compile.sources} PROPERTIES COMPILE_FLAGS ${Param.cxx-flags})
+# Googletest would have -Weffc++ warnings.
+set_source_files_properties(${Test.sources} PROPERTIES COMPILE_FLAGS ${Param.cxx-flags-gtest})
add_executable(freedv-server ${Compile.sources})
--std=c++11 -g -pedantic -Wall -Wextra -Wshadow -DDEBUG
+-std=c++11 -g -pedantic -Wall -Wextra -Wshadow -Weffc++ -DDEBUG
// Global instance of the driver manager used to register
// drivers and to create driver instances.
DriverManager::DriverManager()
+ : audio_input_drivers(0),
+ audio_output_drivers(0),
+ codecs(0),
+ framers(0),
+ keying_output_drivers(0),
+ modems(0),
+ ptt_input_drivers(0),
+ text_input_drivers(0),
+ user_interface_drivers(0)
{
}
void get_overrun() const;
uint8_t * reorder(std::size_t length);
+ // Copy constructor and operator =() disabled.
+ FIFO(const FIFO &);
+ FIFO & operator=(const FIFO &);
public:
/// Create the FIFO object.
/// \param length The size of the fifo, in bytes.
/// UserInterfaces may provide their own drivers for microphone,
/// loudspeaker, TextInput, and both forms of PTT.
class UserInterface : public ::FreeDV::IODevice {
+private:
+ // Copy constructor and operator =() disabled.
+ UserInterface(const UserInterface &);
+ UserInterface & operator=(const UserInterface &);
protected:
/// The external Interfaces object.
///
/// Structure used to pass all of the drivers. Can be modified while the
/// program is running.
class Interfaces {
+private:
+ // Copy constructor and operator=() disabled.
+ Interfaces(const Interfaces &);
+ Interfaces & operator=(const Interfaces &);
public:
Interfaces() : codec(0),
framer(0), keying_output(0), loudspeaker(0),
DriverList * text_input_drivers;
DriverList * user_interface_drivers;
+ // Copy constructor and operator=() disabled.
+ DriverManager(const DriverManager &);
+ DriverManager & operator=(const DriverManager &);
public:
/// Initialize the driver manager.
namespace FreeDV {
FIFO::FIFO(std::size_t size)
- : buffer(new uint8_t[size]), buffer_end(buffer + size)
+ : buffer(new uint8_t[size]), buffer_end(buffer + size), in(buffer), out(buffer)
{
reset();
}
#include "drivers.h"
namespace FreeDV {
- Framer::Framer(const char * name, const char * parameters)
- : Base(name, parameters)
+ Framer::Framer(const char * _name, const char * _parameters)
+ : Base(_name, _parameters)
{
}
std::size_t output_length);
};
- FramerNoOp::FramerNoOp(const char * parameters)
- : Framer("no-op", parameters)
+ FramerNoOp::FramerNoOp(const char * _parameters)
+ : Framer("no-op", _parameters)
{
}
}
std::ostream &
- Interfaces::print(std::ostream & stream, const char * program_name) const
+ Interfaces::print(std::ostream & stream, const char * _program_name) const
{
- if ( program_name ) {
+ if ( _program_name ) {
stream << program_name << " \\" << std::endl;
}
stream << "--codec=\"" << *codec << "\" \\" << std::endl;
#include "drivers.h"
namespace FreeDV {
- IODevice::IODevice(const char * name, const char * parameters)
- : Base(name, parameters)
+ IODevice::IODevice(const char * _name, const char * _parameters)
+ : Base(_name, _parameters)
{
}
#include "drivers.h"
namespace FreeDV {
- KeyingOutput::KeyingOutput(const char * name, const char * parameters)
- : IODevice(name, parameters)
+ KeyingOutput::KeyingOutput(const char * _name, const char * _parameters)
+ : IODevice(_name, _parameters)
{
}
std::size_t ready();
};
- KeyingSink::KeyingSink(const char * parameters)
- : KeyingOutput("sink", parameters)
+ KeyingSink::KeyingSink(const char * _parameters)
+ : KeyingOutput("sink", _parameters)
{
}
#include "drivers.h"
namespace FreeDV {
- Modem::Modem(const char * name, const char * parameters)
- : Base(name, parameters)
+ Modem::Modem(const char * _name, const char * _parameters)
+ : Base(_name, _parameters)
{
}
min_frame_duration() const;
};
- ModemNoOp::ModemNoOp(const char * parameters)
- : Modem("no-op", parameters)
+ ModemNoOp::ModemNoOp(const char * _parameters)
+ : Modem("no-op", _parameters)
{
}
private:
static const int overlong_delay = AudioFrameSamples * 4;
- char * const parameters;
snd_pcm_t * handle;
+ char * const parameters;
bool started;
+ // Copy constructor and operator=() disabled.
+ AudioInALSA(const AudioInALSA &);
+ AudioInALSA & operator=(const AudioInALSA &);
+
NORETURN void
do_throw(const int error, const char * message = 0)
{
};
AudioInALSA::AudioInALSA(const char * p)
- : AudioInput("alsa", p), parameters(strdup(p)), started(false)
+ : AudioInput("alsa", p), handle(0), parameters(strdup(p)), started(false)
{
handle = ALSASetup(
p,
///
class AudioOutALSA : public AudioOutput {
private:
- char * const parameters;
snd_pcm_t * handle;
+ char * const parameters;
bool started;
+ // Copy constructor and operator=() disabled.
+ AudioOutALSA(const AudioOutALSA &);
+ AudioOutALSA & operator=(const AudioOutALSA &);
+
NORETURN void
do_throw(const int error, const char * message = 0)
{
};
AudioOutALSA::AudioOutALSA(const char * p)
- : AudioOutput("alsa", p), parameters(strdup(p)),
- started(false)
+ : AudioOutput("alsa", p), handle(0), parameters(strdup(p)), started(false)
{
handle = ALSASetup(
p,
private:
/// This is true if ready has not yet been sent.
///
- bool ready_one_shot;
bool pressed;
+ bool ready_one_shot;
public:
/// Instantiate push-to-talk source with constant input, for testing.
///
bool state();
};
- PTTConstant::PTTConstant(const char * parameters)
- : PTTInput("constant", parameters), ready_one_shot(true)
+ PTTConstant::PTTConstant(const char * _parameters)
+ : PTTInput("constant", _parameters), pressed(false), ready_one_shot(true)
{
if ( *parameters == 't' )
pressed = true;
#include "drivers.h"
namespace FreeDV {
- PTTInput::PTTInput(const char * name, const char * parameters)
- : IODevice(name, parameters)
+ PTTInput::PTTInput(const char * _name, const char * _parameters)
+ : IODevice(_name, _parameters)
{
}
bool started;
PollType poll_fds[100];
+ // Disable copy constructor and operator=().
+ Run(const Run &);
+ Run & operator=(const Run &);
+
bool add_poll_device(IODevice * device);
NORETURN void do_throw(int error, const char * message);
void key_down();
std::size_t ready();
};
- TextConstant::TextConstant(const char * parameters)
- : TextInput("constant", parameters), index(0), length(strlen(parameters))
+ TextConstant::TextConstant(const char * _parameters)
+ : TextInput("constant", _parameters), index(0), length(strlen(_parameters))
{
}
#include "drivers.h"
namespace FreeDV {
- TextInput::TextInput(const char * name, const char * parameters)
- : IODevice(name, parameters)
+ TextInput::TextInput(const char * _name, const char * _parameters)
+ : IODevice(_name, _parameters)
{
}
virtual std::size_t read16(std::int16_t * array, std::size_t length);
};
- Tone::Tone(const char * parameters)
- : AudioInput("tone", parameters), clock(0)
+ Tone::Tone(const char * _parameters)
+ : AudioInput("tone", _parameters), clock(0)
{
unsigned int index = 0;
unsigned int input = 0;
while ( !p.eof() ) {
float frequency = 0.0;
- float amplitude = 1.0;
+ float _amplitude = 1.0;
if ( index >= ((sizeof(tones) / sizeof(*tones)) - 1) ) {
std::cerr << "Too many tones, number " << index
char c;
p >> c;
if ( !p.fail() && c == ',' ) {
- p >> amplitude;
+ p >> _amplitude;
if ( !p.fail() ) {
c = '\0';
p >> c;
break;
}
}
- if ( frequency == 0.0 || amplitude == 0.0 ) {
+ if ( frequency == 0.0 || _amplitude == 0.0 ) {
input++;
continue;
}
<< frequency << '.' << std::endl;
break;
}
- if ( amplitude < 0.0 || amplitude > 1.0 ) {
+ if ( _amplitude < 0.0 || _amplitude > 1.0 ) {
std::cerr << "tone: amplitude must be in range of 0.0..1.0, is "
- << frequency << '.' << std::endl;
+ << _amplitude << '.' << std::endl;
break;
}
tones[index].frequency = frequency;
- tones[index].amplitude = amplitude;
+ tones[index].amplitude = _amplitude;
index++;
input++;
}
#include "drivers.h"
namespace FreeDV {
- UserInterface::UserInterface(const char * name, const char * parameters, Interfaces *)
- : IODevice(name, parameters)
+ UserInterface::UserInterface(const char * _name, const char * _parameters, Interfaces * _interfaces)
+ : IODevice(_name, _parameters), interfaces(_interfaces)
{
}