public void Dispose()
{
foreach (EventHandler e in DataReady.GetInvocationList())
{
DataReady -= e;
}
}
//When ReceiverClient events
private void OnReceiverClientEvent(object sender, DataEventArgs e)
{
foreach (var track in e.Tracks)
{
// Look for track in list of tracks in airspace
var foundTrack = _airCraftsInAirspaceList.Find(ByTag(track.Tag));
Track trackToValidate = null;
// If already in list - update speed and coordinates.
if (foundTrack != null)
{
double trackSeconds = (track.Time.Minute * 60) + track.Time.Second;
double foundTrackSeconds = (foundTrack.Time.Minute * 60) + foundTrack.Time.Second;
// Workaround
TimeSpan differenceTime = track.Time.Subtract(foundTrack.Time);
var velocity = _trackCalculator.CalculateVelocity(foundTrack.XCoordinate, track.XCoordinate,
foundTrack.YCoordinate, track.YCoordinate,
foundTrack.Altitude, track.Altitude,
0, differenceTime.TotalSeconds);
var compassCourse = _trackCalculator.CalculateCourse(foundTrack.XCoordinate, track.XCoordinate,
foundTrack.YCoordinate, track.YCoordinate);
var newTrack = new Track(foundTrack.Tag, track.XCoordinate, track.YCoordinate,
track.Altitude, track.Time, velocity, compassCourse);
_airCraftsInAirspaceList.Remove(foundTrack);
_airCraftsInAirspaceList.Add(newTrack);
trackToValidate = newTrack;
}
// If not in list - add it This should be tested - intellisense says expression is always true
else if (foundTrack == null)
{
_airCraftsInAirspaceList.Add(track);
trackToValidate = track;
}
// If outside airspace, remove it.
bool inAirSpace = _monitoredAirspace.ValidateAirspace(trackToValidate);
if (!inAirSpace)
{
_airCraftsInAirspaceList.Remove(trackToValidate);
}
}
// Pass on Tracks in monitored airspace if not empty
if (_airCraftsInAirspaceList.Count != 0)
{
var args = new ATMSEventArgs();
args.Tracks = _airCraftsInAirspaceList;
// Raise event if somebody has "subscribed" to it
DataReady?.Invoke(this, args);
}
}
public PipelineReader(System.Management.Automation.Runspaces.PipelineReader <T> pipelineReader)
{
this.pipelineReader = pipelineReader;
pipelineReader.DataReady += (sender, e) =>
{
DataReady?.Invoke(sender, e);
};
}
void _serial_PortDataReveived(Object sender, SerialDataReceivedEventArgs e)
{
SerialPort _Dataport = (SerialPort)sender;
Byte[] ReadData = new Byte[_Dataport.BytesToRead];
for (int i = 0; i < _Dataport.BytesToRead; i++)
{
ReadData[i] = (byte)_Dataport.ReadByte();
}
this.LastreadData = ReadData;
DataReady?.Invoke(this, e);
}
public async void BeginLoad()
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://www.google.com");
HttpResponseMessage msg = await client.GetAsync("");
string content = await msg.Content.ReadAsStringAsync();
Data = content;
DataReady?.Invoke(this, EventArgs.Empty);
}
void OnDataReady()
{
UT60EPacket package = new UT60EPacket(current_package_time_stamp, buffer);
buffer.Clear();
EventArgs e = new UT60EPackageReceivedEventArgs(package);
foreach (EventHandler event_handler in DataReady.GetInvocationList())
{
event_handler.BeginInvoke(this, e, null, null);
}
}
public static void UpdateDataReady(int gameId, DataReady dataReady, string databaseName)
{
string cmdText = string.Format("UPDATE {0}.dbo.GameCompanyMap SET data_ready=@data_ready WHERE game_id=@game_id;", (object)databaseName);
SqlParameter[] sqlParameterArray = new SqlParameter[2]
{
new SqlParameter("@game_id", (object)gameId),
null
};
sqlParameterArray[0].DbType = DbType.Int32;
sqlParameterArray[1] = new SqlParameter("@data_ready", (object)dataReady);
sqlParameterArray[1].DbType = DbType.Int32;
SqlServerHelper.ExecuteNonQuery(CommandType.Text, cmdText, sqlParameterArray);
}
void OnDataReady(object sender, EventArgs e)
{
UT60EPacket package = (e as UT60EPackageReceivedEventArgs).package;
IUT60EData data = package.Parse();
if (data == null)
{
parse_error_count += 1;
}
else if (data.Unit == unit)
{
data_packages.Add(data);
}
else
{
data = null;
}
DataReady.Invoke(this, new UT60EDataReadyEventArgs(data));
}
public void Clear()
{
lock (this)
{
IsEmpty.Set();
DataReady.Reset();
WriteReady.Set();
readclosevent.Reset();
writecloseevent.Reset();
foreach (byte[] block in m_Blocks)
{
FreeBlock(block);
}
m_Blocks.Clear();
m_RPos = 0;
m_WPos = 0;
m_Size = 0;
EOS.Reset();
}
}
public async void Get_Json(string company_name)
{
string base_url = "http://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=";
string Json_Url = String.Concat(base_url + company_name + "&apikey=");
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(Json_Url);
data = await response.Content.ReadAsStringAsync();
data = data.Replace("1. open", "open");
data = data.Replace("2. high", "high");
data = data.Replace("3. low", "low");
data = data.Replace("4. close", "close");
data = data.Replace("5. volume", "volume");
File.WriteAllText(Json_FilePath, data);
_stockvalues = Parse_Json();
//check if data is ready
DataReady?.Invoke(this, EventArgs.Empty);
Console.WriteLine($"file saved to {Json_FilePath}.");
}
private void calculateTransform(ChannelData channel)
{
for (int i = 0; i < transformLength; i++)
{
channel.Complex[i] = new Complex
{
X = channel.InputHistory[i] * window[i],
Y = 0f
};
}
transformProvider.FFT(true, m, channel.Complex);
var e = new FourierTransformEventArgs(
transformLength,
channel.Index,
channel.Complex);
if (DataReady != null)
{
DataReady.Invoke(this, e);
}
}
private void OnDataReady(DataReadyEventArgs e) => DataReady?.Invoke(this, e);
protected virtual void OnDataReady(string path, long size, int count, string name)
{
DataReady?.Invoke(path, size, count, name);
}
/// <summary>
/// It will connect on the server with given IP and Port then listens on it. Use it in the thread/task
/// </summary>
/// <param name="ip">Server IP</param>
/// <param name="port">Server Port</param>
/// <param name="endBytesIdentifier">
/// This identifies the end packet once receive these bytes it will push the packet. If null
/// then it pushes as it receives
/// </param>
/// <param name="connectionTimeoutMs"></param>
/// <param name="receiveTimeOut"></param>
/// <param name="transmissionTimeout"></param>
/// <returns>Connection Status</returns>
public bool Connect(string ip, int port, byte[] endBytesIdentifier = null, int connectionTimeoutMs = 2000, int receiveTimeOut = 1000, int transmissionTimeout = 1000)
{
if (endBytesIdentifier != null)
{
endBytesIdentifier = endBytesIdentifier.Reverse().ToArray();
}
if (IsConnected)
{
return(IsConnected);
}
clientTcp = new TcpClient()
{
ReceiveTimeout = receiveTimeOut, SendTimeout = transmissionTimeout
};
try
{
IAsyncResult result = clientTcp.BeginConnect(ip, port, null, null);
bool success = result.AsyncWaitHandle.WaitOne(connectionTimeoutMs, true);
IsConnected = clientTcp.Connected;
if (!IsConnected)
{
return(IsConnected);
}
Port = port;
Ip = ip;
}
catch (Exception ex)
{
ExceptionHandler?.Invoke(this, ex);
return(IsConnected);
}
try
{
stream = clientTcp.GetStream();
ReplyPacket replyPacket = new ReplyPacket()
{
IsSentAndReplyReceived = true, IPSender = ip
};
IsConnected = true;
List <byte> completePacket = new List <byte>();
Task.Run(async() =>
{
while (clientTcp.Connected)
{
if (!IsConnected)
{
break;
}
if (!stream.DataAvailable)
{
await Task.Delay(1).ConfigureAwait(false);
}
else
{
try
{
byte[] packet = new byte[clientTcp.Available];
await stream.ReadAsync(packet, 0, packet.Length).ConfigureAwait(false);
completePacket.AddRange(packet);
int lenth = completePacket.Count;
if (endBytesIdentifier != null)
{
//this will flush any data that was there before connecting to the software
//if (lenth > 5000) { completePacket.Clear(); continue; }
if (completePacket.Count > endBytesIdentifier.Length)
{
bool isPacketEndIdentified = false;
for (int i = 0; i < endBytesIdentifier.Length; i++)
{
if (completePacket[lenth - (i + 1)] == endBytesIdentifier[i])
{
isPacketEndIdentified = true;
}
else
{
isPacketEndIdentified = false;
break;
}
}
if (isPacketEndIdentified)
{
replyPacket.SetReply(completePacket);
DataReady?.Invoke(this, replyPacket);
completePacket.Clear();
}
}
}
else
{
replyPacket.SetReply(completePacket);
DataReady?.Invoke(this, replyPacket);
completePacket.Clear();
}
}
catch (Exception ex)
{
ExceptionHandler?.Invoke(this, ex);
}
}
}
});
}
catch (Exception ex)
{
ExceptionHandler?.Invoke(this, ex);
}
return(IsConnected);
}
protected virtual void OnDataReady(DataReadyEventArgs e)
{
DataReady?.Invoke(this, e);
}
public static void UpdateDataReady(int gameId, DataReady dataReady)
{
DataHandlerSina.UpdateDataReady(gameId, dataReady, "FootballSina");
}
public override void Write(byte[] buf, int ofs, int count)
{
try
{
int Left = count;
while (Left > 0)
{
switch (WaitHandle.WaitAny(new WaitHandle[] { this.WriteReady, this.writecloseevent }, this.WriteTimeout, false))
{
case 0:
break;
case 1:
//System.Diagnostics.Trace.WriteLine($"{Name} Write closed");
this.towrite = 0;
throw new EndOfStreamException();
default:
this.towrite = 0;
throw new TimeoutException();
}
lock (this)
{
int ToWrite = Math.Min(BlockSize - m_WPos, Left);
var block = GetWBlock();
ToWrite = Math.Min(BlockSize - m_WPos, Left);
System.Array.Copy(buf, ofs + count - Left, block, m_WPos, ToWrite);
m_WPos += ToWrite;
Left -= ToWrite;
m_Size += ToWrite;
this.towrite = Left;
IsEmpty.Reset();
if (m_Size >= this.MaxLength)
{
// Trace.WriteLine("Write, buffer full, writeready.reset()");
this.WriteReady.Reset();
}
/* if (Length >= this.toread)
* {
* // Trace.WriteLine("Write, readready, dataready.set()");
* DataReady.Set();
* }*/
}
}
}
finally
{
// var doset = false;
lock (this)
{
if (Length >= this.toread)
{
// doset = true;
// Trace.WriteLine("Write, readready, dataready.set()");
DataReady.Set();
}
}
}
}
public static List <GameInfo> GetGameInfos(DataReady dataReady)
{
return(DataHandlerSina.GetGameInfosBySQL(string.Format("SELECT * FROM GameInfo g left join GameCompanyMap c on g.id=c.game_id WHERE data_ready={0};", (object)dataReady)));
}
public static List <GameInfo> GetDailyGameInfos(DataReady dataReady)
{
return(DataHandlerSina.GetGameInfosBySQL2(string.Format("SELECT * FROM FootballSinaDaily.dbo.GameInfo_Daily g left join FootballSinaDaily.dbo.GameCompanyMap c on g.id=c.game_id WHERE data_ready={0};", (object)dataReady)));
}
public void SetDataReady(int index)
{
DataReady?.Invoke(index);
}
/// <summary>
/// Transmit a packet to a remote host
/// </summary>
/// <param name="destination">The host to transmit to</param>
/// <param name="buffer">The buffer to transmit</param>
/// <param name="length">The length of the data to transfer</param>
internal void Transmit(IPEndPoint destination, byte[] buffer, int length)
{
DataReady?.Invoke(destination, buffer, length);
}
private void ProcessScmpRecvBuffer(object sender)
{
var bCanProcess = true;
while ((m_recvBuf.Size >= Shared.Scmp.Base.SizeOf) && bCanProcess)
{
// Have received at least a Scmp.Base message
var scmp = new Shared.Scmp.Base();
scmp.Unpack(m_recvBuf.Buffer);
// Determine endianness first thing. The first message
// that makes it here should be the endianness message.
// If it is not (or endianness cannot be determined)
// then we abort.
if (m_endian == Endian.Unknown)
{
var endianness = GetScmpBlob <Shared.Scmp.Endianness>();
SetEndianness(endianness.Order);
// If endianness is still undetermined then we cannot continue
if (m_endian == Endian.Unknown)
{
SledOutDevice.OutLine(
SledMessageType.Error,
Localization.SledTargetErrorUnknownEndianness);
m_recvBuf.Reset();
m_netPlugin.Disconnect();
break;
}
// Remove endianness message from buffer
m_recvBuf.Shuffle(endianness.Length);
// Restart loop to advance "scmp" to next chunk (if a chunk has been received) so we're not
// referencing stale memory and processing the Endianness message more than once.
continue;
}
if (m_recvBuf.Size >= scmp.Length)
{
var bFlag = false;
//Sce.Sled.Shared.SledOutDevice.OutLine(Sce.Sled.Shared.SledMessageType.Info, string.Format("[DebugService] Receiving {0}:{1}", scmp.GetType(), scmp.TypeCode));
// Have receive at least one full Scmp message; process it
switch (scmp.TypeCode)
{
case (UInt16)Shared.Scmp.TypeCodes.Disconnect:
{
m_netPlugin.Disconnect();
bFlag = true;
}
break;
case (UInt16)Shared.Scmp.TypeCodes.Authenticated:
{
m_bAuthenticated = true;
NetPluginConnectedEvent(sender, m_curTarget);
}
break;
case (UInt16)Shared.Scmp.TypeCodes.PluginsReady:
{
NetPluginPluginsReadyEvent(m_curTarget);
}
break;
case (UInt16)Shared.Scmp.TypeCodes.Ready:
{
NetPluginReadyEvent(m_curTarget);
}
break;
case (UInt16)Shared.Scmp.TypeCodes.Version:
AuthenticateVersion();
break;
case (UInt16)Shared.Scmp.TypeCodes.BreakpointBegin:
HandleBreakpointBegin();
break;
case (UInt16)Shared.Scmp.TypeCodes.BreakpointSync:
HandleBreakpointSync();
break;
case (UInt16)Shared.Scmp.TypeCodes.BreakpointEnd:
HandleBreakpointEnd();
break;
case (UInt16)Shared.Scmp.TypeCodes.BreakpointContinue:
HandleBreakpointContinue();
break;
default:
{
// Dispatch message
DataReady.Raise(this, new SledDebugServiceEventArgs(m_curTarget, scmp));
}
break;
}
// Remove this message
if (!bFlag)
{
try
{
// This shouldn't throw now that we catch the problem in Dtlib but lets at least
// stop annoying people with the stupid crashes from not handling the exception.
m_recvBuf.Shuffle(scmp.Length);
}
catch (ArgumentOutOfRangeException ex)
{
SledOutDevice.OutLine(SledMessageType.Error, ex.Message);
// Can't continue so force disconnect
m_netPlugin.Disconnect();
bFlag = true;
}
}
}
else
{
// Not a full message, need to wait until we've received more data
bCanProcess = false;
}
}
}
public bool IsLogging()
{
return(DataReady.GetInvocationList().Count() > 0);
}
