outputmanager.h

amygdata的神经网络算法源代码

/***************************************************************************
                          outputmanager.h  -  description
                             -------------------
    copyright            : (C) 2004 by Matt Grover
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef OUTPUTMANAGER_H
#define OUTPUTMANAGER_H



#include <amygdala/amygdalaclass.h>
#include <vector>
#include <string>
#include <map>

namespace Amygdala {
class SpikeOutput;
class Neuron;
class NeuronGroup;

/** @class OutputManager outputmanager.h amygdala/outputmanager.h
 * A singleton class used to manage SpikeOutput objects and output groups.
 * @author Matt Grover
 */
class OutputManager: public AmygdalaClass {
public:
    static unsigned short AddSpikeOutput(SpikeOutput * so);
    static void EraseSpikeOutput(unsigned short idx);
    static SpikeOutput* GetSpikeOutput(unsigned short idx) { return spikeOut[idx]; }
    
    typedef std::map<AmIdInt, SpikeOutput*>::const_iterator spikeoutput_iterator;
    static spikeoutput_iterator SpikeOutput_begin() { return spikeOut.begin(); }
    static spikeoutput_iterator SpikeOutput_end() { return spikeOut.end(); }
    
    typedef std::map< AmGroupInt, std::vector<Neuron*> >::const_iterator output_group_iterator;
    static output_group_iterator OutputGroup_begin() { return groups.begin(); }
    static output_group_iterator OutputGroup_end() { return groups.end(); }
    
    static void AddNeuronToGroup(Neuron* nrn, AmGroupInt group);

    /** Turn output on or off for group grp. */
    static void EnableOutput(bool enable, unsigned int grp);
    
    static void SendOutput(Neuron* nrn, AmTimeInt outputTime);
protected:
    static void Output(Neuron* spikingNeuron);
    static std::map< AmIdInt, SpikeOutput*> spikeOut;
    //static std::map<OutputGroup*, AmGroupInt> groups;
    static std::map< AmGroupInt, std::vector<Neuron*> > groups;
private:
	OutputManager();
	~OutputManager();
    //friend void SpikingNeuron::SendSpike(AmTimeInt&);
    //friend void InputNeuron::SendInputSpike(AmTimeInt&);
};

}  // namespace Amygdala


#endif