// TRANSMIT
public bool Transmit(IChannelTransmissor transmissor, IState state)
{
if (_transmissors.Contains(transmissor))
{
performDelay(state);
performNoise(state);
return Difussion(transmissor, state);
}
else
{
throw new ExceptionChannel();
}
}
private void DoOnTransmit(IChannelTransmissor receiver, IInformationState state)
{
if (OnTransmit != null)
{ OnTransmit(this, state); };
}
public void RemoveTransmissor(IChannelTransmissor transmissor)
{
checkTransmissorType(transmissor);
internalRemoveTransmissor(transmissor);
}
public virtual bool Receive(IChannelTransmissor transmissor, IState state)
{
DoOnReceive(this, transmissor, state);
Station.Receive(transmissor, state);
return true;
}
public void QuantumReceive(IChannelTransmissor transmissor, IState state)
{
_quantumStation.Receive(transmissor, state);
}
private void RemoveHooks()
{
if (Channel != null)
{
IChannelReceiver[] receivers = Channel.GetAllReceivers();
IChannelTransmissor[] transmissors = Channel.GetAllTransmissors();
if (receivers.Length < 2) { return; }
if (transmissors.Length < 2) { return; }
masterreceiver = receivers[0];
slavereceiver = receivers[1];
mastertransmissor = transmissors[0];
slavetransmissor = transmissors[1];
masterreceiver.OnReceive -= new EventHandlerReceiverData(EventMasterReceive);
slavereceiver.OnReceive -= new EventHandlerReceiverData(EventSlaveReceive);
mastertransmissor.OnTransmit -= new EventHandlerTransmissorData(EventMasterTransmit);
slavetransmissor.OnTransmit -= new EventHandlerTransmissorData(EventSlaveTransmit);
}
}
public override void Receive(IChannelTransmissor transmissor, IState state)
{
//return _receiver.Receive(null, state);
PropagateOnReceive(transmissor, state);
}
protected void internalAddTransmissor(IChannelTransmissor transmissor)
{
_transmissors.Add(transmissor);
}
protected void internalRemoveTransmissor(IChannelTransmissor transmissor)
{
_transmissors.Remove(transmissor);
}
public abstract void Receive(IChannelTransmissor transmissor, IState state);
protected virtual void checkTransmissorType(IChannelTransmissor transmissor)
{
}
protected void PropagateOnTransmit(IChannelTransmissor transmissor, IInformationState state)
{
if (OnTransmit != null)
{ OnTransmit(this, state); };
if (state is IQuantumState)
{
if (OnQuantumTransmit != null)
{ OnQuantumTransmit(this, (IQuantumState)state); };
}
}
protected void PropagateOnReceive(IChannelTransmissor transmissor, IState state)
{
if (OnReceive != null)
{ OnReceive(this, state); };
if (state is IQuantumState)
{
if (OnQuantumReceive != null)
{ OnQuantumReceive(this, (IQuantumState)state); };
}
}
public override void Receive(IChannelTransmissor transmissor, IState state)
{
//bool step1 = ClassicReceive(state);
//bool step2 = QuantumReceive(state);
//return (step1 && step2);
PropagateOnReceive(this, state);
}
private void EventSlaveReceive(IChannelReceiver receiver, IChannelTransmissor transmissor, IState state)
{
if (System.Object.ReferenceEquals(transmissor.Station, receiver.Station)) { return; };
labelDirectionA.ForeColor = Color.Gray;
labelDirectionA.Update();
labelDirectionB.ForeColor = Color.Gray;
labelDirectionB.Update();
panelChannel.BackColor = Color.Gray;
panelChannel.Update();
string shortDebug = null;
if (state is IQuantumState)
{ shortDebug = ((IQuantumState)state).Debugger.ShortDebug; }
if (state is IClassicState)
{ shortDebug = ((IClassicState)state).Debugger.ShortDebug; }
UpdateTextBox(this.textBoxStationB, "RECEIVED STATE", shortDebug);
}
private void DoOnDifussion(IChannelTransmissor transmissor, IState state)
{
if (OnDifussion != null)
{ OnDifussion(this, transmissor, state); };
}
private void EventSlaveTransmit(IChannelTransmissor transmissor, IState state)
{
labelDirectionA.ForeColor = Color.Gray;
labelDirectionA.Update();
labelDirectionB.ForeColor = Color.Red;
labelDirectionB.Update();
panelChannel.BackColor = Color.Red;
panelChannel.Update();
string shortDebug = null;
if (state is IQuantumState)
{ shortDebug = ((IQuantumState)state).Debugger.ShortDebug; }
if (state is IClassicState)
{ shortDebug = ((IClassicState)state).Debugger.ShortDebug; }
UpdateTextBox(this.textBoxStationB, "SENT STATE", shortDebug);
}
private bool PropagateDifussion(IChannelTransmissor transmissor, IState state)
{
bool result = true;
foreach (IChannelReceiver receiver in _receivers)
{
result &= receiver.Receive(transmissor, state);
}
return result;
}
protected void PropagateOnTransmit(IChannelTransmissor transmissor, IState state)
{
if (OnTransmit != null)
{ OnTransmit(this, state); };
if (state is IClassicState)
{
if (OnClassicTransmit != null)
{ OnClassicTransmit(this, (IClassicState)state); };
}
}
public void AddTransmissor(IChannelTransmissor transmissor)
{
checkTransmissorType(transmissor);
internalAddTransmissor(transmissor);
}
protected override void checkTransmissorType(IChannelTransmissor transmissor)
{
if (!(transmissor is IQuantumChannelTransmissor))
{ throw new QuantumChannelException(); }
}
public bool Difussion(IChannelTransmissor transmissor, IState state)
{
DoOnDifussion(transmissor, state);
return PropagateDifussion(transmissor, state);
}
private void DoOnReceive(IChannelReceiver receiver, IChannelTransmissor transmissor, IState state)
{
if (OnReceive != null)
{ OnReceive(receiver, transmissor, state); };
}
public void ClassicReceive(IChannelTransmissor transmissor, IState state)
{
_classicStation.Receive(transmissor, state);
}
