private void DataReceived(object sender, string data)
{
if (data.Trim() == "")
{
return;
}
buffer += data;
if (buffer.EndsWith("!\n"))
{
DataPacket packet = new DataPacket();
var lines = buffer.Split("\n");
for (var i = 0; i < lines.Length; i++)
{
if (lines[i].StartsWith("0-1:24.3"))
{
packet.ParseLine("0-1:24.2.1" + lines[i + 1]);
}
else
{
packet.ParseLine(lines[i]);
}
}
if (packet.IsValid)
{
OnData?.Invoke(this, packet);
}
else
{
Console.WriteLine($"Invalid packet: {packet.ToString()}");
}
buffer = "";
}
}
//private
private async void queryInternal(string q, Tuple <string, dynamic>[] parameters, Guid g)
{
command = new MySqlCommand(q, conn);
if (parameters != null && parameters.Length > 0)
{
for (int i = 0; i < parameters.Length; i++)
{
command.Parameters.AddWithValue(parameters[i].Item1, parameters[i].Item2);
}
}
DbDataReader reader = null;
try {
reader = await command.ExecuteReaderAsync();
} catch (Exception ex) {
OnError?.Invoke(this, new SQLEventArgs(q, parameters, new SQLError()
{
ex = ex
}, new SQLData(), g));
return;
}
SQLData d = new SQLData();
d.recordsAffected = reader.RecordsAffected;
DataColumnCollection columns = reader.GetSchemaTable().Columns;
List <string> tColumns = new List <string>();
for (int i = 0; i < columns.Count; i++)
{
tColumns.Add(columns[i].ColumnName);
}
d.columns = tColumns.ToArray();
List <object[]> tData = new List <object[]>();
while (await reader.ReadAsync())
{
object[] tVals = new object[tColumns.Count];
reader.GetValues(tVals);
tData.Add(tVals);
}
d.data = new object[tData.Count, tColumns.Count];
for (int i = 0; i < tData.Count; i++)
{
for (int j = 0; j < tColumns.Count; j++)
{
d.data[i, j] = tData[i][j];
}
}
OnData?.Invoke(this, new SQLEventArgs(q, parameters, new SQLError(), d, g));
new Thread(delegate() {
sendNext();
}).Start();
}
void Conexion_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
if (OnMessage != null || OnData != null)
{
Thread.Sleep(250);
if (Conexion.BytesToRead > 0)
{
int count = Conexion.BytesToRead;
byte[] Data = new byte[count];
Conexion.Read(Data, 0, count);
string Message = Encoding.ASCII.GetString(Data, 0, Data.Length);
OnData?.Invoke(Conexion, Data);
OnMessage?.Invoke(Conexion, Message);
}
}
}
catch (Exception ex)
{
OnError?.Invoke(Conexion, ex);
}
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details.
/// </summary>
///
public override long expressInterest(Interest interest_0, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat_1)
{
long pendingInterestId_2 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_3 = onData;
OnData onDataSubmit_4 = new ThreadPoolFace.Anonymous_C14(this, finalOnData_3);
OnTimeout finalOnTimeout_5 = onTimeout;
OnTimeout onTimeoutSubmit_6 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C13(this, finalOnTimeout_5);
OnNetworkNack finalOnNetworkNack_7 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_8 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C12(this, finalOnNetworkNack_7);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_9 = new Interest(interest_0);
threadPool_.submit(new ThreadPoolFace.Anonymous_C11(this, onNetworkNackSubmit_8, interestCopy_9,
onDataSubmit_4, pendingInterestId_2, wireFormat_1, onTimeoutSubmit_6));
return(pendingInterestId_2);
}
private void Received(SocketAsyncEventArgs e)
{
try
{
if ((e.SocketError == SocketError.Success) && e.AcceptSocket.Connected)
{
var userToken = (IUserToken)e.UserToken;
var buffer = new byte[e.BytesTransferred];
Buffer.BlockCopy(userToken.ReceiveArgs.Buffer, e.Offset, buffer, 0, buffer.Length);
OnData?.Invoke(this, buffer);
// OnData(this, buffer);
//Array.Clear(buffer, 0, buffer.Length);
buffer = null;
if (clientSocket.Connected)
{
if (!clientSocket.ReceiveAsync(ReceiveSocket))
{
Received(ReceiveSocket);
}
}
}
else
{
RaiseOnError(new SocketException((int)SocketError.Shutdown), "已断开服务连接");
RaiseOnMsg("已断开服务连接166");
}
}
catch (Exception ex)
{
RaiseOnError(ex, "ClientSocketOperation.Received");
RaiseOnMsg("未将对象设置为引用172" + ex.ToString() + clientSocket.Connected);
}
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details.
/// </summary>
///
public override long expressInterest(Interest interest_0, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat_1)
{
long pendingInterestId_2 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_3 = onData;
OnData onDataSubmit_4 = new ThreadPoolFace.Anonymous_C14 (this, finalOnData_3);
OnTimeout finalOnTimeout_5 = onTimeout;
OnTimeout onTimeoutSubmit_6 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C13 (this, finalOnTimeout_5);
OnNetworkNack finalOnNetworkNack_7 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_8 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C12 (this, finalOnNetworkNack_7);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_9 = new Interest(interest_0);
threadPool_.submit(new ThreadPoolFace.Anonymous_C11 (this, onNetworkNackSubmit_8, onDataSubmit_4,
interestCopy_9, onTimeoutSubmit_6, pendingInterestId_2, wireFormat_1));
return pendingInterestId_2;
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details. We make a separate
/// expressInterest overload for supplying a Name vs. Interest to avoid making
/// multiple copies of the Interest.
/// </summary>
///
public override long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat_0)
{
long pendingInterestId_1 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_2 = onData;
OnData onDataSubmit_3 = new ThreadPoolFace.Anonymous_C10(this, finalOnData_2);
OnTimeout finalOnTimeout_4 = onTimeout;
OnTimeout onTimeoutSubmit_5 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C9(this, finalOnTimeout_4);
OnNetworkNack finalOnNetworkNack_6 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_7 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C8(this, finalOnNetworkNack_6);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_8 = net.named_data.jndn.Face.getInterestCopy(name, interestTemplate);
threadPool_.submit(new ThreadPoolFace.Anonymous_C7(this, onTimeoutSubmit_5, onDataSubmit_3, interestCopy_8,
wireFormat_0, pendingInterestId_1, onNetworkNackSubmit_7));
return(pendingInterestId_1);
}
private async Task WorkerAsync()
{
try
{
using (var reader = new StreamReader(_stream, Encoding.UTF8,
detectEncodingFromByteOrderMarks: false,
4096,
leaveOpen: true))
{
while (true)
{
var line = await reader.ReadLineAsync();
if (line == null)
{
return;
}
Debug.WriteLine("RECEIVED : " + line);
OnData?.Invoke(line);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("WORKER CRASHED: " + ex.Message);
}
}
public async void SetLinearMode()
{
await this.DirectSet("/gp/gpWebcam/SETTINGS?fov=4");
Lens = 4;
OnData?.Invoke(this, null);
}
async void Connect()
{
try
{
Socket = new System.Net.WebSockets.ClientWebSocket();
await Socket.ConnectAsync(new Uri(this.Url), CancellationToken.None);
var receiveBytes = new byte[4096];
var receiveBuffer = new ArraySegment <byte>(receiveBytes);
while (Socket.State == WebSocketState.Open)
{
var receivedMessage = await Socket.ReceiveAsync(receiveBuffer, CancellationToken.None);
if (receivedMessage.MessageType == WebSocketMessageType.Close)
{
await
Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "closing websocket",
CancellationToken.None);
}
else
{
var messageBytes = receiveBuffer.Skip(receiveBuffer.Offset).Take(receivedMessage.Count).ToArray();
var rawMessage = new UTF8Encoding().GetString(messageBytes);
OnData.Invoke(this, rawMessage);
}
}
}
catch (System.Exception)
{
Connect();
}
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
if (interest.matchesName(contentData_.getName()))
{
contentCount_[0] = 1;
onData.onData(interest, contentData_);
}
else if (interest.matchesName(cKeyData_.getName()))
{
cKeyCount_[0] = 1;
onData.onData(interest, cKeyData_);
}
else if (interest.matchesName(dKeyData_.getName()))
{
dKeyCount_[0] = 1;
onData.onData(interest, dKeyData_);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
try {
Assert.AssertEquals(3, interest.getLink().getDelegations().size());
} catch (EncodingException ex) {
Assert.Fail("Error in getLink: " + ex);
}
if (interest.matchesName(contentData_.getName()))
{
contentCount_[0] = 1;
onData.onData(interest, contentData_);
}
else if (interest.matchesName(cKeyData_.getName()))
{
cKeyCount_[0] = 1;
onData.onData(interest, cKeyData_);
}
else if (interest.matchesName(dKeyData_.getName()))
{
dKeyCount_[0] = 1;
onData.onData(interest, dKeyData_);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
private async Task ReadData()
{
if (tcpClient.Connected)
{
using (var stream = tcpClient.GetStream())
{
while (!cancellationTokenSource.IsCancellationRequested)
{
var dataRead = await stream.ReadAsync(readBuffer, 0, readBuffer.Length, cancellationTokenSource.Token);
if (dataRead > 0)
{
OnData?.Invoke(this, new DataEventArgs {
Data = readBuffer.Take(dataRead).ToArray()
});
}
else
{
break;
}
}
}
}
Closed?.Invoke(this, null);
}
public async void Reader()
{
var cancelToken = CancellationToken.None;
var headBuffer = new byte[8];
var headSegment = new ArraySegment <byte>(headBuffer);
do
{
var received = await socket.ReceiveAsync(headSegment, cancelToken);
if (received.CloseStatus.HasValue)
{
OnClose?.Invoke();
return;
}
var type = BitConverter.ToInt32(headBuffer, ProtocolTypePosition);
var length = BitConverter.ToInt32(headBuffer, ProtocolLengthPosition);
var bodyBuffer = new byte[length];
var bodySegment = new ArraySegment <byte>(bodyBuffer);
received = await socket.ReceiveAsync(bodySegment, cancelToken);
if (received.CloseStatus.HasValue)
{
OnClose?.Invoke();
return;
}
OnData?.Invoke(type, bodyBuffer);
} while (!socket.CloseStatus.HasValue);
OnClose?.Invoke();
await socket.CloseAsync(socket.CloseStatus.Value, socket.CloseStatusDescription, cancelToken);
}
private void mk_play_data(IntPtr userdata, int track_type, int codec_id, IntPtr data, int len, uint dts, uint pts)
{
unsafe
{
var a = new Span <byte>(data.ToPointer(), len).ToArray();
}
var mediaInfo = new MediaPlayInfo
{
Codec = (EM_Codec)codec_id,
Data = data,
Dts = dts,
IsVideo = track_type == 0,
Length = len,
Pts = pts
};
if (this.OnDataAsync != null)
{
mediaInfo.FillData(true);
_ = Task.Run(() => OnDataAsync.Invoke(mediaInfo));
}
else if (this.OnData != null)
{
OnData.Invoke(mediaInfo);
}
}
protected virtual void receiver()
{
recvCache = new List <byte>();
while (!receiving)
{
Thread.Sleep(Consts.CheckIntervalMilli);
}
while (receiving)
{
if (client.Available == 0)
{
Thread.Sleep(Consts.CheckIntervalMilli); continue;
}
bool invoking = recvCache.Count == 0;
int count = client.Available;
var cache = new byte[count];
client.Client.Receive(cache, count, SocketFlags.None);
recvCache.AddRange(cache); // note that List.AddRange will treat byte[] as ICollection<byte>
if (invoking)
{
OnData?.Invoke(this, new TalknetTcpClientDataEventArgs());
}
}
recvCache = null;
}
public async void SetNarrowMode()
{
await this.DirectSet("/gp/gpWebcam/SETTINGS?fov=6");
Lens = 6;
OnData?.Invoke(this, null);
}
public CustomSocket(OnData onData, OnStatus onStatus)
{
this._onData = onData;
this._onStatus = onStatus;
this._status = SocketStatus.UNDEFINE;
}
private void _ReceiveThread()
{
try
{
var isOpen = _isOpen;
var buffer = new byte[BufferSize];
var remoteIPEP = (EndPoint) new IPEndPoint(IPAddress.Any, 0);
while (isOpen.Value)
{
var recSize = _socket.ReceiveFrom(buffer, 0, BufferSize, SocketFlags.None, ref remoteIPEP);
var packet = new byte[recSize];
Array.Copy(buffer, packet, recSize);
OnData?.Invoke((IPEndPoint)remoteIPEP, packet);
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
_Cleanup();
OnStop?.Invoke(ex);
}
}
public async void SetWideMode()
{
await this.DirectSet("/gp/gpWebcam/SETTINGS?fov=0");
Lens = 0;
OnData?.Invoke(this, null);
}
private void ReadAllFromQueue()
{
LinError readResult;
do
{
ReceivedMessage msg;
readResult = PLinApi.Read(_clientHandle, out msg);
var(processorResult, processorMessage) = MessageProcessor.Process(readResult, msg);
switch (processorResult)
{
case MessageProcessorResult.EmptyQueue:
break;
case MessageProcessorResult.Error:
case MessageProcessorResult.Info:
OnError?.Invoke(this, processorMessage);
break;
case MessageProcessorResult.Regular:
OnData?.Invoke(this, msg.Data);
break;
default:
throw new NotImplementedException();
}
} while (readResult == LinError.Ok);
}
public async void Reader()
{
var headBuffer = new byte[8];
while (socket.Connected)
{
if (!await stream.ReadAll(headBuffer, headBuffer.Length))
{
OnClose?.Invoke();
return;
}
var type = BitConverter.ToInt32(headBuffer, ProtocolTypePosition);
var length = BitConverter.ToInt32(headBuffer, ProtocolLengthPosition);
var bodyBuffer = new byte[length];
if (!await stream.ReadAll(bodyBuffer, length))
{
OnClose?.Invoke();
return;
}
OnData?.Invoke(type, bodyBuffer);
}
}
private void Received(SocketAsyncEventArgs e)
{
try
{
if ((e.SocketError == SocketError.Success) && e.AcceptSocket.Connected)
{
var userToken = (IUserToken)e.UserToken;
var buffer = new byte[e.BytesTransferred];
Buffer.BlockCopy(userToken.ReceiveArgs.Buffer, e.Offset, buffer, 0, buffer.Length);
OnData?.BeginInvoke(this, buffer, null, null);
if (clientSocket.Connected)
{
if (!clientSocket.ReceiveAsync(ReceiveSocket))
{
Received(ReceiveSocket);
}
}
}
else
{
RaiseOnError(new SocketException((int)SocketError.Shutdown), "已断开服务连接");
}
}
catch (Exception ex)
{
RaiseOnError(ex, "ClientSocketOperation.Received");
}
}
public async void SetRes1080()
{
await Stop();
Resolution = "1080";
OnData?.Invoke(this, null);
Start();
}
public void OnNext(StreamData <GazePointData> value)
{
double x = value.Data.X;
double y = value.Data.Y;
double ts = value.Data.Timestamp;
OnData?.Invoke(this, new ReceivedDataEventArgs(new Point(x, y), ts));
}
public Anonymous_C1(Consumer paramouter_Consumer, Interest interest_0,
OnData onData_1, net.named_data.jndn.encrypt.EncryptError.OnError onError_2)
{
this.interest = interest_0;
this.onData = onData_1;
this.onError = onError_2;
this.outer_Consumer = paramouter_Consumer;
}
public async Task <GoProStatus> GetStatus()
{
var status = await Get <GoProStatus>("/gp/gpControl/status");
this.HandleStatusResponse(status);
OnData?.Invoke(this, null);
return(status);
}
public PackClientSide(Socket clientSocket, IPEndPoint remoteEndPoint)
: base(clientSocket, remoteEndPoint)
{
m_onData = new OnData(OnDataReceived);
m_onMsgRead4Tx = new OnMessageReadyToTx(OnMsgRead4Tx);
m_onEnd = new OnEnd(OnTransationEnd);
m_receiverPackLib = new ReceiverPackLib.ReceiverPackLib(m_Id,m_onData, m_onEnd, null, m_onMsgRead4Tx);
}
public PackClientSide(Socket clientSocket, IPEndPoint remoteEndPoint)
: base(clientSocket, remoteEndPoint)
{
m_onData = new OnData(OnDataReceived);
m_onMsgRead4Tx = new OnMessageReadyToTx(OnMsgRead4Tx);
m_onEnd = new OnEnd(OnTransationEnd);
m_receiverPackLib = new ReceiverPackLib.ReceiverPackLib(m_Id, m_onData, m_onEnd, null, m_onMsgRead4Tx);
}
public void ReceiveData(string data)
{
if (OnData.HasDelegate)
{
byte[] byteArray = ANSIEncoder.GetBytes(data);
OnData.InvokeAsync(byteArray);
}
}
/// <summary>
/// Create a new ExponentialReExpress where onTimeout expresses the interest
/// again with double the interestLifetime. If the interesLifetime goes over
/// maxInterestLifetime, then call the given onTimeout. If this internally
/// gets onData, just call the given onData.
/// </summary>
///
private ExponentialReExpress(Face face, OnData onData, OnTimeout onTimeout,
double maxInterestLifetime)
{
face_ = face;
callerOnData_ = onData;
callerOnTimeout_ = onTimeout;
maxInterestLifetime_ = maxInterestLifetime;
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
NetworkNack networkNack = new NetworkNack();
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.NO_ROUTE);
onNetworkNack.onNetworkNack(interest, networkNack);
}
public PendingInterestTable.Entry add(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack)
{
int removeRequestIndex = removeRequests_.indexOf(pendingInterestId);
if (removeRequestIndex >= 0) {
// removePendingInterest was called with the pendingInterestId returned by
// expressInterest before we got here, so don't add a PIT entry.
ILOG.J2CsMapping.Collections.Collections.RemoveAt(removeRequests_,removeRequestIndex);
return null;
}
PendingInterestTable.Entry entry = new PendingInterestTable.Entry (pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack);
ILOG.J2CsMapping.Collections.Collections.Add(table_,entry);
return entry;
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout)
{
return expressInterest(name, interestTemplate, onData, onTimeout,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, WireFormat wireFormat)
{
return expressInterest(name, interestTemplate, onData, onTimeout, null,
wireFormat);
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack)
{
return expressInterest(name, null, onData, onTimeout, onNetworkNack,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat)
{
return expressInterest(name, null, onData, onTimeout, onNetworkNack,
wireFormat);
}
public long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat) throws IOException {
public Anonymous_C14(ThreadPoolFace paramouter_ThreadPoolFace,
OnData finalOnData_0)
{
this.finalOnData = finalOnData_0;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
/// <summary>
/// Create a new Entry with the given fields. Note: You should not call this
/// directly but call PendingInterestTable.add.
/// </summary>
///
public Entry(long pendingInterestId, Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
this.isRemoved_ = false;
pendingInterestId_ = pendingInterestId;
interest_ = interest;
onData_ = onData;
onTimeout_ = onTimeout;
onNetworkNack_ = onNetworkNack;
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData, WireFormat wireFormat)
{
return expressInterest(name, null, onData, null, wireFormat);
}
public Anonymous_C3(Node paramouter_Node, Interest interestCopy_0,
OnNetworkNack onNetworkNack_1, Face face_2, OnTimeout onTimeout_3,
long pendingInterestId_4, WireFormat wireFormat_5, OnData onData_6)
{
this.interestCopy = interestCopy_0;
this.onNetworkNack = onNetworkNack_1;
this.face = face_2;
this.onTimeout = onTimeout_3;
this.pendingInterestId = pendingInterestId_4;
this.wireFormat = wireFormat_5;
this.onData = onData_6;
this.outer_Node = paramouter_Node;
}
void DoTest(object arg)
{
string fileName = (string)arg;
UpdateControls updateControls = new UpdateControls(Update_Controls);
if (File.Exists("received_file"))
{
File.Delete("received_file");
}
FileStream fs = File.OpenRead(fileName);
if (fs == null)
{
return;
}
byte[] raw_file = new byte[fs.Length];
if (fs.Read(raw_file, 0, raw_file.Length) != raw_file.Length)
{
return;
}
fs.Close();
fs = null;
DateTime initialStamp,finishStamp;
bool firstIteration = true;
ulong ticks_sum = 0;
ulong iterations = 0;
byte[] buf;
OnData onData = new OnData(OnDataReceived);
OnEnd onEnd = new OnEnd(OnTransactionEnd);
do
{
initialStamp = DateTime.Now;
buf = raw_file;
if (File.Exists("received_file"))
{
File.Delete("received_file");
}
ReceiverPackLib.ReceiverPackLib receiverPackLib = new ReceiverPackLib.ReceiverPackLib(onData,onEnd,null);
SenderPackLib.SenderPackLib senderPackLib = new SenderPackLib.SenderPackLib(buf);
senderPackLib.AddData(buf,false);
#if false
senderPackLib.AddLast();
bool SameChunk;
while ((buf = senderPackLib.GetChunk(out SameChunk)) != null)
{
byte[] predMsg = receiverPackLib.ReceiverOnData(buf,0);
if (predMsg != null)
{
byte[] predAckMsg = senderPackLib.SenderOnData(predMsg, 0);
receiverPackLib.ReceiverOnData(predAckMsg, 0);
}
}
#endif
finishStamp = DateTime.Now;
object[] args = new object[4];
args[0] = firstIteration;
if (firstIteration)
{
args[1] = (ulong)(finishStamp.Ticks - initialStamp.Ticks);
firstIteration = false;
}
else
{
ticks_sum += (ulong)(finishStamp.Ticks - initialStamp.Ticks);
iterations++;
args[1] = ticks_sum / iterations;
}
args[2] = (ulong)iterations;
args[3] = true;
Invoke(updateControls, args);
while (checkBoxPause.Checked)
{
Thread.Sleep(1000);
}
} while (checkBoxDoUntilStopped.Checked);
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy">to use.</param>
/// <param name="onData">expressInterest and data is the received Data object.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public void expressInterest(long pendingInterestId,
Interest interestCopy, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat, Face face)
{
// Set the nonce in our copy of the Interest so it is saved in the PIT.
interestCopy.setNonce(nonceTemplate_);
interestCopy.refreshNonce();
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE) {
// We are connected. Simply send the interest without synchronizing.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
return;
}
lock (onConnectedCallbacks_) {
// TODO: Properly check if we are already connected to the expected host.
if (!transport_.isAsync()) {
// The simple case: Just do a blocking connect and express.
transport_.connect(connectionInfo_, this, null);
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
// Make future calls to expressInterest send directly to the Transport.
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE;
return;
}
// Handle the async case.
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.UNCONNECTED) {
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED;
// expressInterestHelper will be called by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_,new Node.Anonymous_C3 (this, interestCopy, onNetworkNack, face,
onTimeout, pendingInterestId, wireFormat, onData));
IRunnable onConnected = new Node.Anonymous_C2 (this);
transport_.connect(connectionInfo_, this, onConnected);
} else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED) {
// Still connecting. add to the interests to express by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_,new Node.Anonymous_C1 (this, interestCopy, onData, onTimeout,
onNetworkNack, wireFormat, face, pendingInterestId));
} else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE)
// We have to repeat this check for CONNECT_COMPLETE in case the
// onConnected callback was called while we were waiting to enter this
// synchronized block.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
else
// Don't expect this to happen.
throw new Exception("Node: Unrecognized _connectStatus "
+ connectStatus_);
}
}
/// <summary>
/// Do the work of expressInterest once we know we are connected. Add the entry
/// to the PIT, encode and send the interest.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy"></param>
/// <param name="onData"></param>
/// <param name="onTimeout"></param>
/// <param name="onNetworkNack"></param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
internal void expressInterestHelper(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat, Face face)
{
PendingInterestTable.Entry pendingInterest = pendingInterestTable_
.add(pendingInterestId, interestCopy, onData, onTimeout,
onNetworkNack);
if (pendingInterest == null)
// removePendingInterest was already called with the pendingInterestId.
return;
if (onTimeout != null
|| interestCopy.getInterestLifetimeMilliseconds() >= 0.0d) {
// Set up the timeout.
double delayMilliseconds = interestCopy
.getInterestLifetimeMilliseconds();
if (delayMilliseconds < 0.0d)
// Use a default timeout delay.
delayMilliseconds = 4000.0d;
face.callLater(delayMilliseconds, new Node.Anonymous_C0 (this, pendingInterest));
}
// Special case: For timeoutPrefix_ we don't actually send the interest.
if (!timeoutPrefix_.match(interestCopy.getName())) {
Blob encoding = interestCopy.wireEncode(wireFormat);
if (encoding.size() > getMaxNdnPacketSize())
throw new Exception(
"The encoded interest size exceeds the maximum limit getMaxNdnPacketSize()");
transport_.send(encoding.buf());
}
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData)
{
return expressInterest(name, null, onData, null,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the interest as required by Node.expressInterest.
node_.expressInterest(pendingInterestId, interest, onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout)
{
return expressInterest(interest, onData, onTimeout,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Interest interest, OnData onData,
WireFormat wireFormat)
{
return expressInterest(interest, onData, null, wireFormat);
}
public Anonymous_C5(Consumer paramouter_Consumer, Interest interest_0,
OnData onData_1, net.named_data.jndn.encrypt.EncryptError.OnError onError_2)
{
this.interest = interest_0;
this.onData = onData_1;
this.onError = onError_2;
this.outer_Consumer = paramouter_Consumer;
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the name object as required by Node.expressInterest.
node_.expressInterest(pendingInterestId,
getInterestCopy(name, interestTemplate), onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details. We make a separate
/// expressInterest overload for supplying a Name vs. Interest to avoid making
/// multiple copies of the Interest.
/// </summary>
///
public override long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat_0)
{
long pendingInterestId_1 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_2 = onData;
OnData onDataSubmit_3 = new ThreadPoolFace.Anonymous_C10 (this, finalOnData_2);
OnTimeout finalOnTimeout_4 = onTimeout;
OnTimeout onTimeoutSubmit_5 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C9 (this, finalOnTimeout_4);
OnNetworkNack finalOnNetworkNack_6 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_7 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C8 (this, finalOnNetworkNack_6);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_8 = net.named_data.jndn.Face.getInterestCopy(name, interestTemplate);
threadPool_.submit(new ThreadPoolFace.Anonymous_C7 (this, onDataSubmit_3, onTimeoutSubmit_5, interestCopy_8,
onNetworkNackSubmit_7, wireFormat_0, pendingInterestId_1));
return pendingInterestId_1;
}
public Anonymous_C11(ThreadPoolFace paramouter_ThreadPoolFace,
OnNetworkNack onNetworkNackSubmit_0, OnData onDataSubmit_1,
Interest interestCopy_2, OnTimeout onTimeoutSubmit_3,
long pendingInterestId_4, WireFormat wireFormat_5)
{
this.onNetworkNackSubmit = onNetworkNackSubmit_0;
this.onDataSubmit = onDataSubmit_1;
this.interestCopy = interestCopy_2;
this.onTimeoutSubmit = onTimeoutSubmit_3;
this.pendingInterestId = pendingInterestId_4;
this.wireFormat = wireFormat_5;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
