BasicNodes.h

// BasicNodes.h
// ofxPDSP
// Nicola Pisanti, MIT License, 2016


#ifndef PDSP_CORE_BASICNODES_H_INCLUDED
#define PDSP_CORE_BASICNODES_H_INCLUDED



#include <vector>
#include <math.h>
#include <cassert>
#include <stdint.h>
#include <limits>
#include "../pdspFunctions.h"
#include "../pdspConstants.h"
#include "../../math/header.h"
#include "Preparable.h"
#include <cstring>
#include <atomic>
#include <iostream>
#include "../../flags.h"

namespace pdsp {

class Patchable;
class InputNode;
class OutputNode;
class ValueNode;
class NullInput;
class NullOutput;

//-------------------------------------OUTPUT DATA------------------------------------------------
class OutputData {
public:
    OutputData( OutputNode* node, bool multiply, float multiplier )
        : node( node ), multiply( multiply ), multiplier( multiplier ) {  };

    OutputNode* node;
    bool multiply;
    float multiplier;
};

//----------------------------------NODE REFERENCES--------------------------

class NamedInput {
public:
    NamedInput( const char* tag, InputNode* pInput ) : tag( tag ), input( pInput ) {};

    const char*     tag;
    InputNode*      input;
};

class NamedOutput {
public:
    NamedOutput( const char* tag, OutputNode* pOutput ) : tag( tag ), output( pOutput ) {};

    const char*     tag;
    OutputNode*     output;
};

//--------------------------------PATCHABLE------------------------------------------



class Patchable {
    friend class Unit;
    friend class InputNode;
    friend class Switch;
    
public:
    Patchable();

    void    resetInputToDefault();
    void    resetOutputToDefault();

    Patchable&         in( const char* tag );
    
    
    Patchable&         out( const char* tag );
    
    void disconnectIn();  
    
    void disconnectOut();
    
    void disconnectAll();

    InputNode& getSelectedInput();
    
    OutputNode& getSelectedOutput();

    std::vector<std::string> getInputsList();
    
    std::vector<std::string> getOutputsList();

protected:

    void    addOutput( const char* tag, OutputNode & output );
    
    void    addInput( const char* tag, InputNode & input );

    void    addModuleOutput( const char* tag, Patchable & unit );
    
    void    addModuleInput( const char* tag, Patchable & unit );

    [[deprecated("Replaced by addModuleOutput() for a less ambigous nomenclature")]]
    void    addUnitOutput( const char* tag, Patchable & unit );
    
    [[deprecated("Replaced by addModuleInput() for a less ambigous nomenclature")]]
    void    addUnitInput( const char* tag, Patchable & unit );
private:
    std::vector<NamedInput>         inputs;
    std::vector<NamedOutput>        outputs;

    static NullInput        invalidInput;
    static NullOutput       invalidOutput;
    
    InputNode*      selectedInput;
    OutputNode*     selectedOutput;
    
    void    clearAllAddedNodes();
};


//-------------------------------------Unit------------------------------------------------

class Unit :  public Preparable, public Patchable {
    friend class InputNode;

public:
    Unit();
    Unit(const Unit & other);
    Unit& operator= (const Unit & other);
    Unit (Unit&& other);
    Unit& operator= (Unit&& other); 
    
    virtual void setOversampleLevel( int newOversampleLevel );
    
    int getOversampleLevel() const;

protected:

    virtual void process( int bufferSize ) noexcept = 0;
    
    virtual void prepareUnit( int expectedBufferSize, double sampleRate ) = 0;
  
  
    virtual void releaseResources( ) override = 0;    
    
    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    
    //functions to manipulate ins/outs---------------------------------------------
    
    const float*    processInput( InputNode& node, int& stateNow );
    
    float           processAndGetSingleValue( InputNode& input, int pos ); //WARNING! pos is not checked

    //const float*    getOutputBuffer( OutputNode& node );
    
    
    float*          getOutputBufferToFill( OutputNode& node );
    
    void            setControlRateOutput( OutputNode& node, float scalarValue );
    
    void            setOutputToZero( OutputNode& node );

    void            updateOutputNodes();
    
    virtual ~Unit() {};    
    

    
private:

    int oversample;

};


//-------------------------------------OUTPUT NODE------------------------------------------------

class OutputNode : public Preparable {
    friend class InputNode;
    friend class Unit;
    friend class OutputData;
    friend class PatchNode;
    friend class Switch;
    friend class ExternalInput;
    friend class Processor;
    friend class UpSampler;
    friend class DownSampler;
    friend class Patchable;
    
public:

    OutputNode( int oversample );
    OutputNode();
    OutputNode( const OutputNode& other );
    OutputNode& operator= ( const OutputNode& other );

    virtual ~OutputNode();
    
    void connect( InputNode& inputNode );
    
    void disconnect( InputNode& inputNode );
    
    void disconnectAll();

    virtual float getCRValue() const;

    const float* getBuffer() const;
    
    const int getState() const;
    
    const std::vector<InputNode*> & getOutputs() const;

    bool isConnected();
    
    bool notConnected();
    
    const int getOversampleLevel() const;
    
    OutputNode& setMultiplyOnConnection( float multiplier );

    static const int getGlobalProcessingTurnId();
protected:

    float* buffer;
    int state;
    Unit* parent;   
    int oversampleLevel;
    
private:

    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    void releaseResources() override;
    virtual void setOversampleLevel( int newOversample );

    virtual bool exists();

    void addInputToList( InputNode* node );
    void removeOutputFromList( InputNode* toRemove );

    int connections;
    std::vector<InputNode*> outputs;

    static std::atomic<int> globalProcessingTurnId;

    int baseBufferSize;
    
    static void setTurn( int newTurn ) ;
    
    static void nextTurn();


    Unit* getParent() const;
    void setParent( Unit* parent );
    void updateTurnId();
    
    bool multiply;
    float nextMultiplier;

    int lastProcessedTurnId;

};



//-------------------------------------VALUE NODE------------------------------------------------
class ValueNode :  public OutputNode {

public:
    ValueNode();
    ValueNode( const ValueNode& other );
    ValueNode& operator= ( const ValueNode& other );
    ~ValueNode();


    float getCRValue() const override;
    
    void set( float value );
    
    float value();
    
    OutputNode& setAndGetNode( float value );

private:
    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    void releaseResources() override;
    void setOversampleLevel( int newOversample ) override;    
    std::atomic<float> nodeValue;

};


//-------------------------------------INPUT NODE------------------------------------------------
class InputNode : public Preparable
    //public Input 
    {
    friend class OutputNode;
    friend class Unit;
    friend class PatchNode;
    friend class Switch;
    friend class UpSampler;
    friend class DownSampler;
    friend class Patchable;

public:
    InputNode( int oversample );
    InputNode();
    virtual ~InputNode();
    InputNode( const InputNode& other ); // copy constructor
    InputNode& operator= ( const InputNode& other ); // copy assignment
    
    
    void connect( OutputNode& outputNode );


  
    virtual void disconnect( OutputNode& outputNode );
    
    virtual void disconnectAll();

    virtual void connectFloat( float value );
    
    void disconnectFloat();

    const float* getBuffer() const;
    
    const int getState() const;
    
    void setDefaultValue( float newDefault );
    
    
    bool isConnected();
    
    void enableBoundaries( float lo, float hi );
    
    void disableBoundaries();
    
    int getRequiredOversampleLevel() const;
    
    //void connectExclusive( OutputNode& outputNode );    
    //virtual void connectFloatExclusive( float value );
protected:

    virtual void setRequiredOversampleLevel( int newOversample );

private:

    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    void releaseResources() override;
    void process() noexcept;

    virtual void removeInputUnilateral( const OutputNode& outputNode );

    virtual bool exists();

    float* buffer;
    float* sumBuffer;
    int state;

    bool clampToBoundaries;
    float lowBoundary;
    float highBoundary;
    
    int connections;
    std::vector<OutputData> inputs;

    bool internalScalarIsConnected;
    ValueNode internalScalar;

    int baseBufferSize;

    float lastValue;
    float defaultValue;
    
    int requiredOversampleLevel;   
};

//-----------------------------------NULL OUTPUT----------------------------

class NullOutput : public ValueNode {

private:
    virtual bool exists() override {
        return false;
    }
    
};


//-------------------------------------NULL INPUT---------------------------------------

class NullInput : public InputNode {

public:
    NullInput() {}

private:
    bool exists()override {
        return false;
    }
    
    void prepareToPlay( int expectedBufferSize, double sampleRate ) override {}
    void releaseResources() override {}

};

} // namespace pdps END



#endif  // BASICNODES_H_INCLUDED