/// <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;
}
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);
}
/// <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);
}
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);
}
/// <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);
}
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 override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
Assert.AssertEquals(expectedInterest_, interest.getName());
++timeoutCount_[0];
onTimeout.onTimeout(interest);
return(0);
}
/// <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;
}
public Anonymous_C3(Node paramouter_Node, Interest interestCopy_0,
OnData onData_1, WireFormat wireFormat_2, OnTimeout onTimeout_3,
long pendingInterestId_4, Face face_5, OnNetworkNack onNetworkNack_6)
{
this.interestCopy = interestCopy_0;
this.onData = onData_1;
this.wireFormat = wireFormat_2;
this.onTimeout = onTimeout_3;
this.pendingInterestId = pendingInterestId_4;
this.face = face_5;
this.onNetworkNack = onNetworkNack_6;
this.outer_Node = paramouter_Node;
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
if (interest.getName().isPrefixOf(expiredCertificate.getName()))
{
onData.onData(interest, expiredCertificate);
}
else
{
originalProcessInterest.processInterest(interest, onData,
onTimeout, onNetworkNack);
}
}
public Anonymous_C7(ThreadPoolFace paramouter_ThreadPoolFace,
OnTimeout onTimeoutSubmit_0, OnData onDataSubmit_1,
Interest interestCopy_2, WireFormat wireFormat_3,
long pendingInterestId_4, OnNetworkNack onNetworkNackSubmit_5)
{
this.onTimeoutSubmit = onTimeoutSubmit_0;
this.onDataSubmit = onDataSubmit_1;
this.interestCopy = interestCopy_2;
this.wireFormat = wireFormat_3;
this.pendingInterestId = pendingInterestId_4;
this.onNetworkNackSubmit = onNetworkNackSubmit_5;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
++expressInterestCallCount_[0];
Name interestName = new Name(interest.getName());
interestName.append(timeMarker_);
Assert.AssertEquals(true, outer_TestProducer.encryptionKeys.Contains(interestName));
onData.onData(interest, (Data)ILOG.J2CsMapping.Collections.Collections.Get(outer_TestProducer.encryptionKeys, interestName));
return(0);
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
CertificateV2 certificate = outer_ValidatorFixture.cache_.find(interest);
if (certificate != null)
{
onData.onData(interest, certificate);
}
else
{
onTimeout.onTimeout(interest);
}
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
Assert.AssertEquals(expectedInterest_, interest.getName());
try {
Assert.AssertEquals(3, interest.getLink().getDelegations().size());
} catch (EncodingException ex) {
Assert.Fail("Error in getLink: " + ex);
}
++timeoutCount_[0];
onTimeout.onTimeout(interest);
return(0);
}
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;
}
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>
/// If processInterest_ is not null, call
/// processInterest_.processInterest(interest, onData, onTimeout, onNetworkNack)
/// which must call one of the callbacks to simulate the response. Otherwise,
/// just call onTimeout(interest) to simulate a timeout. This adds a copy of
/// the interest to sentInterests_ .
/// </summary>
///
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
// Makes a copy of the interest.
ILOG.J2CsMapping.Collections.Collections.Add(sentInterests_, new Interest(interest));
if (processInterest_ != null)
{
processInterest_.processInterest(interest, onData, onTimeout,
onNetworkNack);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
Assert.AssertEquals(expectedInterest_, interest.getName());
bool gotInterestName = false;
Name interestName = null;
for (int i = 0; i < 3; ++i)
{
interestName = new Name(interest.getName());
if (i == 0)
{
interestName.append(timeMarkerFirstHop_);
}
else if (i == 1)
{
interestName.append(timeMarkerSecondHop_);
}
else if (i == 2)
{
interestName.append(timeMarkerThirdHop_);
}
// matchesName will check the Exclude.
if (interest.matchesName(interestName))
{
gotInterestName = true;
++requestCount_[0];
break;
}
}
if (gotInterestName)
{
onData.onData(interest,
(Data)ILOG.J2CsMapping.Collections.Collections.Get(outer_TestProducer.encryptionKeys, interestName));
}
return(0);
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
// Make a copy of the interest.
ILOG.J2CsMapping.Collections.Collections.Add(sentInterests_, new Interest(interest));
Data data = storage_.find(interest);
if (data != null)
{
ILOG.J2CsMapping.Collections.Collections.Add(sentData_, new Data(data));
onData.onData(interest, data);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
/// <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());
}
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
try {
// Create another key for the same identity and sign it properly.
PibKey parentKey = outer_TestValidator.fixture_.keyChain_
.createKey(outer_TestValidator.fixture_.subIdentity_);
PibKey requestedKey = outer_TestValidator.fixture_.subIdentity_.getKey(interest
.getName());
// Copy the Name.
Name certificateName = new Name(requestedKey.getName());
certificateName.append("looper").appendVersion(1);
CertificateV2 certificate = new CertificateV2();
certificate.setName(certificateName);
// Set the MetaInfo.
certificate.getMetaInfo().setType(net.named_data.jndn.ContentType.KEY);
// Set the freshness period to one hour.
certificate.getMetaInfo().setFreshnessPeriod(3600 * 1000.0d);
// Set the content.
certificate.setContent(requestedKey.getPublicKey());
// Set SigningInfo.
SigningInfo // Set SigningInfo.
paras = new SigningInfo(parentKey);
// Validity period from 10 days before to 10 days after now.
double now = net.named_data.jndn.util.Common.getNowMilliseconds();
paras.setValidityPeriod(new ValidityPeriod(now - 10 * 24
* 3600 * 1000.0d, now + 10 * 24 * 3600 * 1000.0d));
outer_TestValidator.fixture_.keyChain_.sign(certificate, paras);
onData.onData(interest, certificate);
} catch (Exception ex) {
Assert.Fail("Error in InfiniteCertificateChain: " + ex);
}
}
/// <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>
/// 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;
}
public long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat) throws IOException {
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;
}
/// <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());
}
}
public Anonymous_C12(ThreadPoolFace paramouter_ThreadPoolFace,
OnNetworkNack finalOnNetworkNack_0)
{
this.finalOnNetworkNack = finalOnNetworkNack_0;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
public Anonymous_C8(ThreadPoolFace paramouter_ThreadPoolFace,
OnNetworkNack finalOnNetworkNack_0)
{
this.finalOnNetworkNack = finalOnNetworkNack_0;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
/// <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);
}
/// <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>
/// 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>
/// 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>
/// 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, onData, wireFormat,
onTimeout, pendingInterestId, face, onNetworkNack));
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, onData, pendingInterestId, wireFormat,
face, onNetworkNack, interestCopy, onTimeout));
}
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>
/// 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_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;
}
