copypaste typo

Author: camilleg

VAlgorithm.c++

@@ -75,31 +75,6 @@ VAlgorithm::VAlgorithm(void) :
 	hpf_d.setHiAllLopassGain(1., 0., 0.);
 }
 
-//===========================================================================
-//     VAlgorithm copy constructor
-//
-//	The buffer should not be shared, and the
-//	new object needs its own place in the Generators
-//	list. Don't copy amp modulation either.
-//	;; Probably bugs in here, but it's not called as far as I can tell.
-//
-VAlgorithm::VAlgorithm(VAlgorithm& alg) :
-	mute(alg.mute),
-	pause(alg.pause),
-	pan(alg.pan),
-	elev(alg.elev),
-	modGain(0L),
-	modScale(0L),
-	modPan(0L),
-	modElev(0L),
-	fLinearEnv(0)
-{
-	position = Generators.insert( Generators.end(), this );
-	setGain(alg.getGain());
-	scaleGain(alg.getGainScale());
-	setInputGain(alg.getInputGain());
-}
-
 VAlgorithm::~VAlgorithm()
 {
 // remove the dead generator from the list
@@ -111,10 +86,6 @@ void VAlgorithm::invertAmp(int fInvert)
 	fInvertAmp = fInvert;
 }
 
-//===========================================================================
-//		setAmps
-//
-
 void VAlgorithm::setAmp(float a, float t)
 {
 	if (!fLinearEnv)
@@ -612,11 +583,9 @@ VAlgorithm::updateDistance(void)
 		}
 }
 
-//===========================================================================
 //===========================================================================
 //=====================  The final mixing bus of VSS ========================
 //===========================================================================
-//===========================================================================
 
 //	FOutputSamples 1,2
 // Utility functions to handle pause and mute states,
@@ -847,7 +816,6 @@ VAlgorithm::OutputSamples4(int howMany, float* putEmHere, int nchansAlgorithm, i
 //	for copying and scaling their samples into putEmHere[]).
 //
 //	Update amplitudes every sample.
-//
 void
 VAlgorithm::outputSamples( int howMany, float* putEmHere, int nchans )
 {
@@ -867,7 +835,3 @@ VAlgorithm::outputSamples( int howMany, float* putEmHere, int nchans )
 	// Store the result in the output buffer putEmHere[].
 	OutputSamples3(howMany, putEmHere, nchans);
 }
-
-void VAlgorithm::generateSamples(int)
-{
-}

VAlgorithm.h

@@ -32,8 +32,6 @@ using VAlgorithmList = std::set<VAlgorithm*>;
 //	in VSS. All other synthesis algorithms must be derived from VAlgorithm.
 class VAlgorithm
 {
-//	internal parameters (all private, only accessible thru access members)
-private:
 // 	If mute is true, this instance is _not_ directly contributing to output.
 	int		mute;	
 
@@ -161,13 +159,12 @@ class VAlgorithm
 public:
 	virtual void outputSamples(int howMany, float* putEmHere, int nchans);
 
-// 	generateSamples() should be overridden by all derived algorithms
-//	that do not override outputSamples(). generateSamples() computes 
-//	samples and stuffs them in the local circular buffer. If a derived 
-//	algorithm class overrides outputSamples(), then it may not use/need
-//	a generateSamples() member. Otherwise we would make it pure virtual.
 protected:
-	virtual	void generateSamples(int);
+	// generateSamples() must be overridden by any class that does
+	// not override outputSamples().  It computes samples and stuffs
+	// them in the local circular buffer. If a derived class overrides
+	// outputSamples(), then it may not need a generateSamples().
+	virtual	void generateSamples(int) {}
 
 //	Flag and utility functions called by the default implementation of outputSamples()
 //	If outputSamples() must be overridden by the algorithm, the author may choose to use
@@ -189,9 +186,10 @@ class VAlgorithm
 	inline void setDistanceImmediately(void);
 
 public:
-		VAlgorithm(void);	
-		VAlgorithm(VAlgorithm&);
-		virtual ~VAlgorithm();				
+	VAlgorithm();
+	VAlgorithm(const VAlgorithm&) = delete;
+	VAlgorithm& operator=(const VAlgorithm&) = delete;
+	virtual ~VAlgorithm();				
 
 // "buffer" is private, not protected... derived classes get at it through
 // ZeroBuf(), Input(), Output(), operator[](), etc.
@@ -222,5 +220,4 @@ class VAlgorithm
 		{ bufDst = buffer; // Copy samples from *this to bufDst.
 		  bufDst.Map(howMany, nchansAlg, nchansDst); // Transform the samples.
 		}
-
 };

VFloatParam.h

@@ -2,6 +2,8 @@
 #pragma once
 #include "VModulator.h"
 
+// Included only by stk4/stk.h.
+
 // 	Class FloatParam updates a smoothly (linearly) modulating float 
 //	parameter. FloatParam should be set inactive whenever the slope 
 //	is zero.
@@ -41,6 +43,8 @@ class FloatParam : public VModulatorOld<float, RcvrType>
 	void init(VHandler* p) { pparent = p; }
 
 	~FloatParam() 	{}
+	FloatParam(const FloatParam&) = delete;
+    FloatParam& operator=(const FloatParam&) = delete;
 
 //	Return the current value of the modulation.
 	float currentValue(void);

VGenActor.h

@@ -127,8 +127,8 @@ class HandlerListIterator
 	HandlerListIterator(const HandlerListIterator &hli) : it(hli.it) {}
 	~HandlerListIterator() 	{}
 
-	HandlerListIterator & operator ++() 	{ it++; return *this; }
-	HandlerListIterator & operator ++(int) 	{ it++; return *this; }
+	HandlerListIterator & operator ++() 	{ ++it; return *this; }
+	HandlerListIterator & operator ++(int) 	{ ++it; return *this; }
 	HandlerListIterator & operator=( HandlerList::iterator i ) 
 											{ it = i; return *this; }
 

VHandler.h

@@ -78,6 +78,8 @@ class VFloatArray : public VModulator
 public:
 	VFloatArray(int sizeArg, const float* oldVals, const float* newVals, float modTime);
 	~VFloatArray();
+	VFloatArray(const VFloatArray&) = delete;
+    VFloatArray& operator=(const VFloatArray&) = delete;
 	int SetAttribute(VHandler*, IParam);
 };
 
@@ -147,6 +149,7 @@ class VHandler : public VActor
 	VHandler(VAlgorithm* const);
 	virtual	~VHandler();
 	VHandler() = delete;
+	VHandler(const VHandler&) = delete;
 	VHandler& operator=(const VHandler&) = delete;
 
 	void setInputGain(float, float time = timeDefault);

VModulator.h

@@ -1,4 +1,3 @@
-//	This fragment of the vss renaissance brought to you by Kelly Fitz, 1996.
 #pragma once
 #include "VActor.h"
 
@@ -22,9 +21,9 @@
 template<class ParamType, class RcvrType> 
 class VModulatorOld : public VActor
 {
-//	If the updateFn member is set, then it will be called with the
-//	current value of the modulation whenever act() is called (at the
-//	vss control rate).
+	//	If the updateFn member is set, then it will be called with the
+	//	current value of the modulation whenever act() is called (at the
+	//	vss control rate).
 public:
 	typedef	void (RcvrType::*UpdtFn)(ParamType);
 	// this fails, so UpdtFn is public not protected:  friend class FloatParam<>;
@@ -35,24 +34,25 @@ class VModulatorOld : public VActor
 public:
 	VModulatorOld(void) : VActor(), updateFn(NULL), receiver(NULL) {}
 	VModulatorOld(RcvrType * r, UpdtFn f) : VActor(), updateFn(f), receiver(r) {}
-virtual	~VModulatorOld() {}
+	virtual	~VModulatorOld() {}
+	VModulatorOld(const VModulatorOld&) = delete;
+	VModulatorOld& operator=(const VModulatorOld&) = delete;
 
-// 	Member for implementing asynchronous modulation behavior.
-//	The default behavior is to call a parameter update function
-//	(if it has been set) with the current value of the modulation.
-virtual void act(void)
+	// 	Member for implementing asynchronous modulation behavior.
+	//	The default behavior is to call a parameter update function
+	//	(if it has been set) with the current value of the modulation.
+	virtual void act()
 	{
 	VActor::act();
-
 	if (isActive() && updateFn)
 		(receiver->*updateFn)(currentValue());
 	}
 
-//	Current value access for converting to type ParamType.
-	operator ParamType(void)	{ return currentValue(); }
+	//	Current value access for converting to type ParamType.
+	operator ParamType() { return currentValue(); }
 
-//	Derived classes _must_ provide a member for returning their
-//	current modulation value. This is the only member that must
-//	be provided by derived classes.
-virtual ParamType currentValue(void) = 0;
+	//	Derived classes _must_ provide a member for returning their
+	//	current modulation value. This is the only member that must
+	//	be provided by derived classes.
+	virtual ParamType currentValue() = 0;
 };

filter.h

@@ -9,8 +9,7 @@
 
 class filter
 {
-private:
-//	Internal synthesis stateholders.
+//	Internal state.
 	float za0, zb0, zb1;		// prewarped analog filter coefficients
 	float zA0, zB0, zB1;		// BLT-mapped digital filter coefficients
 	float stateZi1;				// first-order state variable
@@ -21,13 +20,11 @@ class filter
 	float Alp, Ahp, Aap;		// Lowpass, Highpass, and Allpass gains
 
 public:
-//	Parameter access members.
-	float getFrequency(void)	const { return w0 / (2.0 * M_PI); }
-	float getLowpassGain(void)	const { return Alp; }
-	float getHighpassGain(void)	const { return Ahp; }
-	float getAllpassGain(void)	const { return Aap; }
+	float getFrequency()	const { return w0 / (2.0 * M_PI); }
+	float getLowpassGain()	const { return Alp; }
+	float getHighpassGain()	const { return Ahp; }
+	float getAllpassGain()	const { return Aap; }
 
-//	Parameter update members.
 	void setFrequency(float f)
 		{
 		const float fNyquist = globs.SampleRate / 2.0;
@@ -37,18 +34,16 @@ class filter
 		za0 = tan(w0 * globs.OneOverSR / 2.0);
 		computeCoef();
 		}
-	void setLowpassGain  (float A) { Alp = A; computeCoef(); }
-	void setHighpassGain (float A) { Ahp = A; computeCoef(); }
-	void setAllpassGain  (float A) { Aap = A; computeCoef(); }
-	void setHiAllLopassGain  (float H, float A, float L)
-		{ Ahp=H; Aap=A; Alp=L; computeCoef(); }
+	void setLowpassGain(float A)  { Alp = A; computeCoef(); }
+	void setHighpassGain(float A) { Ahp = A; computeCoef(); }
+	void setAllpassGain(float A)  { Aap = A; computeCoef(); }
+	void setHiAllLopassGain(float H, float A, float L) { Ahp=H; Aap=A; Alp=L; computeCoef(); }
 
-//	Input/output access members.
-	float	getOutput(void)		{ return output; }
-	void	setInput(float In)	{ input = In; }
+	float getOutput() const { return output; }
+	void setInput(float In)	{ input = In; }
 
 //	Utility members.
-	void computeCoef(void)
+	void computeCoef()
 		{
 		// za0 is computed in setFrequency()
 		zb0 = za0 * (Alp - Aap);
@@ -59,22 +54,22 @@ class filter
 		}
 
 //	Sample generation.
-	void computeSamp(void)
+	void computeSamp()
 		{
-		float state = input - zA0 * stateZi1;	// state equation
+		const auto state = input - zA0 * stateZi1;	// state equation
 		output = zB0 * stateZi1 + zB1 * state;	// output equation
 		stateZi1 = state;						// state update
 		}
 
-//	Construction/destruction.
-	filter(void) :
-	stateZi1(0.0),
-	input(0.0),
-	output(0.0),
-	w0(2.0 * M_PI * 1000.0),
-	Alp(1.0),
-	Ahp(0.0),
-	Aap(0.0)
-		{ setFrequency(1000.); }
+	// setFrequency() clobbers za0 w0 zb0 zb1 zA0 zB0 zB1,
+	// but they're in the init list anyways to satisfy -Weffc++.
+	filter() :
+		za0(0.0), zb0(0.0), zb1(0.0),
+		zA0(0.0), zB0(0.0), zB1(0.0),
+		stateZi1(0.0),
+		input(0.0), output(0.0),
+		w0(2.0 * M_PI * 1000.0),
+		Alp(1.0), Ahp(0.0), Aap(0.0)
+			{ setFrequency(1000.); }
 	~filter() {}
 };

vssglobals.h

@@ -47,6 +47,8 @@ class VSSglobals
 
 	VSSglobals();
 	~VSSglobals();
+	VSSglobals(const VSSglobals&) = delete;
+	VSSglobals& operator=(const VSSglobals&) = delete;
 };
 
 //;; These public members should be hidden behind set/get function calls,