Leslie Sanford - Professional Profile

class DisposableInterface
{
public:
    virtual ~DisposableInterface()
    {
    }
};

template<class T>
class Disposable : public DisposableInterface
{
public:
    Disposable(T *target)
    {
        this->target = target;
    }

    ~Disposable()
    {
        delete target;
    }

private:
    T *target;
};

class PluginBase : public AudioEffectX
{
public:
    virtual ~PluginBase()
    {
        std::list<DisposableInterface *>::iterator it;

        for(it = objects.begin(); it != objects.end(); it++)
        {
            delete *it;
        }
    }

    // Stuff...

    template<class T>
    void AddToGarbageCollector(T *object)
    {
        objects.push_back(new Disposable<T>(object));
    }
};

AudioEffect *createEffectInstance(audioMasterCallback audioMaster)
{
    Plugin *plugin = new MyPlugin();

    Lfo *lfo = new Lfo();
    AdsrEnvelope *env = new AdsrEnvelope();
    Oscillator *osc = new Oscillator(lfo, env);

    plugin->AddToGarbageCollector(lfo);
    plugin->AddToGarbageCollector(env);
    plugin->AddtoGarbageCollector(osc);

    // Stuff...

    return plugin;
}

class PluginBase : public AudioEffectX
{
public:

    template<class T>
    void AddTempoTarget(T *object)
    {
        tempoTargets.push_back(new TempoTarget(object));
    }
};

std::list<TempoTargetInterface *>::iterator it;

for(it = tempoTargets.begin(); it != tempoTargets.end(); it++)
{
    (*it)->Tempo(newTempo);
}

void Copy(float *first, float *last, float *out) 
{ 
    while(first != last) 
    { 
        *out = *first; 
 
        first++; 
        out++; 
    }    
} 

void Copy(int *first, int *last, int *out) 
{ 
    while(first != last) 
    { 
        *out = *first; 
 
        first++; 
        out++; 
    }    
} 

template<typename InputIterator, typename OutputIterator> 
void Copy(InputIterator *first, 
          InputIterator *last, 
          OutputIterator *out) 
{ 
    while(first != last) 
    { 
        *out = *first; 
 
        first++; 
        out++; 
    }    
} 

float SineOscillator(float *first, 
                     float *last, 
                     float phase, 
                     float increment) 
{ 
    while(first != last) 
    { 
        phase += increment; 

        while(phase > PI2) 
        { 
            phase -= PI2; 
        } 
 
        *first = sin(phase); 
 
        first++; 
    } 
 
    return phase; 
} 

template<typename OutputIterator, 
         typename Oscillator, 
         typename Waveform> 
Oscillator Oscillate(OutputIterator first, 
                     OutputIterator last, 
                     Oscillator osc, 
                     Waveform wave) 
{ 
    while(first != last) 
    { 
        osc.phase += osc.increment; 
 
        while(osc.phase >= osc.length) 
        { 
            osc.phase -= osc.length; 
        } 
 
        *first = wave(osc.phase); 
 
        first++; 
    } 
 
    return osc; 
} 

Oscillate(&buffer[0], &buffer[BUFFER_SIZE], myOsc, sin); 

myOsc = Oscillate(&buffer[0], 
                  &buffer[BUFFER_SIZE], 
                  myOsc, 
                  sin);

Oscillate<float *, MyOscillator &, Sine>(&buffer[0], 
                                         &buffer[BUFFER_SIZE], 
                                         myOsc, 
                                         Sine());

Oscillate<float *, MyOscillator &, Sine &>(&buffer[0], 
                                           &buffer[BUFFER_SIZE], 
                                           myOsc, 
                                           mySine);

public class MyClass
{
    private SomeObject obj;
 
    private int a;
 
    private int b;
 
    public MyClass(SomeObject obj)
    {
        #region Require
 
        if(obj == null)
        {
            throw new ArgumentNullException("obj");
        }
  
        #endregion
 
        this.obj = obj;
        this.a = obj.CalculateSomething();
        this.b = obj.CalculateSomethingElse();
    }
 
    public void DoSomething()
    {
        a = obj.CalculateSomething();
 
        b = obj.CalculateSomethingElse();
    }
}

public class MyClass
{
    private SomeObject obj;
 
    private int a;
 
    private int b;
 
    public MyClass(SomeObject obj)
    {
        #region Require
 
        if(obj == null)
        {
            throw new ArgumentNullException("obj");
        }
  
        #endregion
 
        this.obj = obj;
        this.a = obj.CalculateSomething();
        this.b = obj.CalculateSomethingElse();
    }
 
    public void DoSomething()
    {
        int tempA = obj.CalculateSomething();
 
        int tempB = obj.CalculateSomethingElse();
 
        // Now we can update the object's fields.
        a = tempA;
        b = tempB;
    }
}

public class RefactoredValues
{
    private int a;
 
    private int b;
 
    public RefactoredValues(SomeObject obj)
    {
        #region Require
 
        if(obj == null)
        {
            throw new ArgumentNullException("obj");
        }
  
        #endregion
 
        this.a = obj.CalculateSomething();
        this.b = obj.CalculateSomethingElse();
    }
 
    public int A
    {
        get
        {
            return a;
        }
    }
 
    public int B
    {
        get
        {
            return b;
        }
    }
}
 
public class MyClass
{
    SomeObject obj;
 
    RefactoredValues v;
  
    public MyClass(SomeObject obj)
    {
        #region Require
 
        if(obj == null)
        {
            throw new ArgumentNullException("obj");
        }
  
        #endregion
 
        this.obj = obj;
 
        v = new RefactoredValues(obj);
    }
 
    public void DoSomething()
    {
        v = new RefactoredValues(obj);
    }
}

SomeObject obj = new SomeObject();

// Sending object message to do something.
obj.DoSomething();

public interface ISomeInterface
{    
    void DoSomething();
}

ISomeInterface obj = new SomeObject();

// Sending object message to do something.
obj.DoSomething();

public interface ISink
{    
    void Send(Message msg);
}

// SomeObject implements the ISink interface.
ISink obj1 = new SomeObject();

AnotherObject obj2 = new AnotherObject(obj1);

obj2.Go();

public class ClassWithEvents
{    
    public event EventHandler SomethingHappened;    
    // ...
}

public class SomeObject
{    
    public void DoSomething()    
    {        
        // ...    
    }
}

ClassWithEvents obj1 = new ClassWithEvents();

SomeObject obj2 = new SomeObject();

ob1.SomethingHappened += delegate(object sender, EventArgs e)
{    
    ob2.DoSomething();
};

public delegate void MessageReceivedEventHandler(object sender, MessageReceivedEventArgs e); 

public class Device 
{ 
    public event MessageReceivedEventHandler MessageReceived; 

    // ... 
} 

public class Client 
{ 
    public void Send(Message msg) 
    { 
        // Do stuff... 
    } 
} 

public class Application 
{ 
    public static void Main() 
    { 
        Device dev = new Device(); 
        Client c = new Client(); 

        // An anonymous method connected to the 
        // MessageReceived event. 
        dev.MessageReceived += delegate(object sender, MessageReceivedEventArgs e) 
        { 
            // Delegate the message to the client class. 
            c.Send(e.Message); 
        }; 


        // Other stuff... 
    }
} 

public interface IChannelSink
{
    void ProcessMessage(IChannelMessage message);
}

public interface IChannelSource
{
    IChannelSink ChannelSink
    {
        get;
        set;
    }
}

public interface IChannelSink
{
    void ProcessMessage(ChannelMessage message);

    IChannelSink NextChannelSink
    {
        get;
        set;
    }
}

InputDevice inDevice = new InputDevice(0);
UserSink userSink = new UserSink();    // Some user defined channel sink.
ChannelStopper stopper = new ChannelStopper();
OutputDevice outDevice = new OutputDevice(0);

inDevice.ChannelSink = userSink;

userSink.NextChannelSink = stopper;

stopper.NextChannelSink = outDevice;

// Start processing messages.
inDevice.StartRecording();

public interface IChannelSource
{
    event EventHandler<ChannelEventArgs> ChannelMessageOccurred;
}

public interface IChannelSink
{
    void Connect(IChannelSource source);
    void Disconnect(IChannelSource source);
}

public interface ISource<T> where T : EventArgs
{
    event EventHandler<T> MessageOccurred;
}

public interface ISink<T> where T : EventArgs
{
    void Connect(ISource<T> source);
    void Disconnect(ISource<T> source);
}

public void Connect(IChannelSource source)
{
    source.ChannelMessageOccurred += new EventHandler<ChannelEventArgs>(HandleChannelMessage);
}

public void Disconnect(IChannelSource source)
{
    source.ChannelMessageOccurred -= new EventHandler<ChannelEventArgs>(HandleChannelMessage);
}

public void Connect(IChannelSource source)
{
    if(sources.Contains(source))
    {
        return;
    }

    source.ChannelMessageOccurred += new EventHandler<ChannelEventArgs>(HandleChannelMessage);

    sources.Add(source);
}

public void Disconnect(IChannelSource source)
{
    source.ChannelMessageOccurred -= new EventHandler<ChannelEventArgs>(HandleChannelMessage);

    sources.Remove(source);
}

public void Dispose()
{
    foreach(IChannelSource source in sources)
    {
        source.ChannelMessageOccurred -= new EventHandler<ChannelEventArgs>(HandleChannelMessage);
    }
}

A Simpler Way

public class SomeClass
{
    public event EventHandler SomethingOccurred;
}

public class AnotherClass
{
    public void Send(object sender, EventArgs e)
    {
        // Do stuff...
    }
}

SomeClass sc = new SomeClass();
AnotherClass ac = new AnotherClass();

sc.SomethingOccurred += as.Send;

public interface IMessage
{
    void Accept(IMessageVisitor);
}

public class MessageA : IMessage
{
    public void Accept(IMessageVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class MessageA : IMessage
{
    public void Accept(IMessageVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public interface IMessageVisitor
{
    void Visit(MessageA message);

    void Visit(MessageB message);
}

public class MessageDispatcher : IMessageVisitor
{
    public event EventHandler MessageAOccurred;

    public event EventHandler MessageBOccurred;

    public void Visit(MessageA message)
    {
        OnMessageAOccurred();
    }

    public void Visit(MessageB message)
    {
        OnMessageBOccurred();
    }

    protected virtual void OnMessageAOccurred()
    {
        EventHandler handler = MessageAOccurred;

        if(handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    protected virtual void OnMessageBOccurred()
    {
        EventHandler handler = MessageBOccurred;

        if(handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }
}

public class MessageCollection
{
    private List<IMessage> messages = new List<IMessage>();

    // Other class declarations, methods, properties, etc...

    public IEnumerable<int> Iterator(IMessageVisitor visitor)
    {
        int index = 0;

        foreach(IMessage message in messages)
        {
            yield return index;

            message.Accept(visitor);

            index++;
        }
    }
}

public class Program
{
    private MessageCollection messages = new MessageCollection();

    private MessageDispatcher dispatcher = new MessageDispatcher();

    public Program()
    {
        dispatcher.MessageAOccurred += EventHandler(HandleMessageA);
    }

    // Other class declarations, methods, properties, etc...

    private void HandleMessageA(object sender, EventArgs e)
    {
        // Do something here.
    }

    public void ProcessMessages()
    {
        foreach(int index in messages.Iterator(dispatcher))
        {
            // Do something with index here.
        }
    }
}