bool RPolyline::reverse() {
RPolyline nPolyline;
QList<QSharedPointer<RShape> > segments = getExploded();
// skip last segment if polyline is closed and add flag instead:
int iLast = segments.count()-1;
if (isClosed()) {
iLast--;
}
for (int i=iLast; i>=0; i--) {
QSharedPointer<RShape> seg = segments.at(i);
QSharedPointer<RDirected> directed = seg.dynamicCast<RDirected>();
directed->reverse();
nPolyline.appendShape(*seg);
}
nPolyline.setClosed(closed);
*this = nPolyline;
return true;
}
/**
* Ends polyline and adds the last entity if the polyline is closed
*/
void RS_Polyline::endPolyline() {
RS_DEBUG->print("RS_Polyline::endPolyline");
if (isClosed()) {
RS_DEBUG->print("RS_Polyline::endPolyline: adding closing entity");
// remove old closing entity:
if (closingEntity!=NULL) {
removeEntity(closingEntity);
}
// add closing entity to the polyline:
closingEntity = createVertex(data.startpoint, nextBulge);
if (closingEntity!=NULL) {
RS_EntityContainer::addEntity(closingEntity);
//data.endpoint = data.startpoint;
}
}
calculateBorders();
}
SUMOReal
PositionVector::area() const {
if (size() < 3) {
return 0;
}
SUMOReal area = 0;
PositionVector tmp = *this;
if (!isClosed()) { // make sure its closed
tmp.push_back(tmp[0]);
}
const int endIndex = (int)tmp.size() - 1;
// http://en.wikipedia.org/wiki/Polygon
for (int i = 0; i < endIndex; i++) {
area += tmp[i].x() * tmp[i + 1].y() - tmp[i + 1].x() * tmp[i].y();
}
if (area < 0) { // we whether we had cw or ccw order
area *= -1;
}
return area / 2;
}
bool ZipFile::closeImpl() {
bool ret = true;
s_pcloseRet = 0;
if (!isClosed()) {
if (m_gzFile) {
s_pcloseRet = gzclose(m_gzFile);
ret = (s_pcloseRet == 0);
m_gzFile = nullptr;
}
setIsClosed(true);
if (m_innerFile.is<File>()) {
m_innerFile.getTyped<File>()->close();
}
if (m_tempFile.is<File>()) {
m_tempFile.getTyped<File>()->close();
m_tempFile.reset();
}
}
File::closeImpl();
return ret;
}
//----------------------------------------------------------------------
// connect
//----------------------------------------------------------------------
bool PipeConnection::connect()
{
LBASSERT( getDescription()->type == CONNECTIONTYPE_PIPE );
if( !isClosed( ))
return false;
_setState( STATE_CONNECTING );
_sibling = new PipeConnection;
_sibling->_sibling = this;
if( !_createPipes( ))
{
close();
return false;
}
_setState( STATE_CONNECTED );
_sibling->_setState( STATE_CONNECTED );
return true;
}
//----------------------------------------------------------------------
// read
//----------------------------------------------------------------------
void NamedPipeConnection::readNB( void* buffer, const uint64_t bytes )
{
if( isClosed( ))
return;
ResetEvent( _read.hEvent );
DWORD use = LB_MIN( bytes, CO_READ_BUFFER_SIZE );
if( ReadFile( _fd, buffer, use, &_readDone, &_read ) )
{
LBASSERT( _readDone > 0 );
SetEvent( _read.hEvent );
}
else if( GetLastError() != ERROR_IO_PENDING )
{
LBWARN << "Could not start overlapped receive: " << lunchbox::sysError
<< ", closing connection" << std::endl;
close();
}
}
void Blob::close(ExecutionContext* executionContext, ExceptionState& exceptionState)
{
if (isClosed()) {
exceptionState.throwDOMException(InvalidStateError, "Blob has been closed.");
return;
}
// Dereferencing a Blob that has been closed should result in
// a network error. Revoke URLs registered against it through
// its UUID.
DOMURL::revokeObjectUUID(executionContext, uuid());
// A Blob enters a 'readability state' of closed, where it will report its
// size as zero. Blob and FileReader operations now throws on
// being passed a Blob in that state. Downstream uses of closed Blobs
// (e.g., XHR.send()) consider them as empty.
OwnPtr<BlobData> blobData = BlobData::create();
blobData->setContentType(type());
m_blobDataHandle = BlobDataHandle::create(std::move(blobData), 0);
m_isClosed = true;
}
PointCoordinateType ccPolyline::computeLength() const
{
PointCoordinateType length = 0;
unsigned vertCount = size();
if (vertCount > 1 && m_theAssociatedCloud)
{
unsigned lastVert = isClosed() ? vertCount : vertCount-1;
for (unsigned i=0; i<lastVert; ++i)
{
CCVector3 A;
getPoint(i,A);
CCVector3 B;
getPoint((i+1)%vertCount,B);
length += (B-A).norm();
}
}
return length;
}
bool PlainFile::closeImpl() {
bool ret = true;
s_pcloseRet = 0;
if (!isClosed()) {
if (m_stream) {
s_pcloseRet = fclose(m_stream);
m_stream = nullptr;
} else if (getFd() >= 0) {
s_pcloseRet = ::close(getFd());
}
if (m_buffer) {
free(m_buffer);
m_buffer = nullptr;
}
ret = (s_pcloseRet == 0);
setIsClosed(true);
setFd(-1);
}
File::closeImpl();
return ret;
}
bool MgPath::crossWithPath(const MgPath& p, const Box2d& box, Point2d& ptCross) const
{
MgPathCrossCallback cc(box, ptCross);
if (isLine() && p.isLine()) {
return (mglnrel::cross2Line(getPoint(0), getPoint(1),
p.getPoint(0), p.getPoint(1), ptCross)
&& box.contains(ptCross));
}
if (isLines() && p.isLines()) {
for (int m = getCount() - (isClosed() ? 0 : 1), i = 0; i < m; i++) {
Point2d a(getPoint(i)), b(getPoint(i + 1));
for (int n = p.getCount() - (p.isClosed() ? 0 : 1), j = 0; j < n; j++) {
Point2d c(p.getPoint(j)), d(p.getPoint(j + 1));
if (mglnrel::cross2Line(a, b, c, d, cc.tmpcross)
&& box.contains(cc.tmpcross)) {
float dist = cc.tmpcross.distanceTo(box.center());
if (cc.mindist > dist) {
cc.mindist = dist;
ptCross = cc.tmpcross;
}
}
}
}
}
else if (isLine() && p.getSubPathCount() == 1) {
cc.a = getPoint(0);
cc.b = getPoint(1);
p.scanSegments(cc);
}
else if (p.isLine() && getSubPathCount() == 1) {
cc.a = p.getPoint(0);
cc.b = p.getPoint(1);
scanSegments(cc);
}
return cc.mindist < box.width();
}
const SocketAddress& ServerSocket::getLocalAddress(void) const
throw (IOException&)
{
MX_ASSERT(!isClosed());
if (NULL == local_)
{
struct sockaddr_in6 sa;
size_t saLen = sizeof(struct sockaddr_in6);
::memset(&sa, 0, sizeof(sa));
if (0 != mxos::getsockname(handle_, (struct sockaddr*) &sa, &saLen))
{
THROW3(IOException, "Can't get sock name", mxos::getLastSocketError());
}
local_ = new SocketAddress;
local_->set((struct sockaddr*) &sa, saLen);
}
return *local_;
}
void RSpline::print(QDebug dbg) const {
dbg.nospace() << "RSpline(";
RShape::print(dbg);
dbg.nospace() << ", degree: " << getDegree();
dbg.nospace() << ", order: " << getOrder();
dbg.nospace() << ", closed: " << isClosed();
dbg.nospace() << ", periodic: " << isPeriodic();
dbg.nospace() << ", start point: " << getStartPoint();
dbg.nospace() << ", end point: " << getEndPoint();
dbg.nospace() << ", start tan: " << getTangentAtStart();
dbg.nospace() << ", end tan: " << getTangentAtEnd();
dbg.nospace() << ", t_min: " << getTMin();
dbg.nospace() << ", t_max: " << getTMax();
QList<RVector> controlPoints = getControlPointsWrapped();
dbg.nospace() << ",\ncontrolPoints (" << controlPoints.count() << "): ";
for (int i=0; i<controlPoints.count(); ++i) {
dbg.nospace() << i << ": " << controlPoints.at(i) << ", ";
}
QList<RVector> fitPoints = getFitPoints();
dbg.nospace() << ",\nfitPoints (" << fitPoints.count() << "): ";
for (int i=0; i<fitPoints.count(); ++i) {
dbg.nospace() << i << ": " << fitPoints.at(i) << ", ";
}
QList<double> knotVector = getKnotVector();
dbg.nospace() << ",\nknots (" << knotVector.count() << "): ";
for (int i=0; i<knotVector.count(); ++i) {
dbg.nospace() << i << ": " << knotVector.at(i) << ", ";
}
knotVector = getActualKnotVector();
dbg.nospace() << ",\ninternally used knots (" << knotVector.count() << "): ";
for (int i=0; i<knotVector.count(); ++i) {
dbg.nospace() << i << ": " << knotVector.at(i) << ", ";
}
}
//----------------------------------------
vector <ofPoint>& ofxBox2dPolygon::getVertices() {
if(body == NULL) {
return;
}
const b2Transform& xf = body->GetTransform();
for (b2Fixture * f = body->GetFixtureList(); f; f = f->GetNext()) {
b2PolygonShape * poly = (b2PolygonShape*)f->GetShape();
if(poly) {
ofPolyline::clear();
for(int i=0; i<poly->GetVertexCount(); i++) {
b2Vec2 pt = b2Mul(xf, poly->GetVertex(i));
ofPolyline::addVertex(pt.x*OFX_BOX2D_SCALE, pt.y*OFX_BOX2D_SCALE);
}
if(isClosed()) ofPolyline::close();
}
}
return ofPolyline::getVertices();
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
void xPipeOutputStream::write(xArray<xbyte>& b, int off, int len) throw(xIOException,xIndexOutOfBoundsException)
{
if(isClosed())
throw xIOException(_T("Cannot write data, pipe closed"));
if(len <= 0 || off+len > b.size() || off < 0)
throw xIndexOutOfBoundsException();
#ifdef XTK_OS_WINDOWS
while ( len > 0 )
{
DWORD chunkWritten = 0;
if (!::WriteFile(m_hPipeOut, b.getRawData() + off + (int)chunkWritten, len, &chunkWritten, NULL))
{
if(::GetLastError() == ERROR_BROKEN_PIPE)
{
close();
throw xIOException(_T("Broken pipe, cannot write"));
}
else
throw xIOException(_T("Error while writing on pipe"),::GetLastError());
}
if (!chunkWritten)
break;
len -= (int)chunkWritten;
}
#elif defined(XTK_OS_UNIX)
while ( len > 0 )
{
ssize_t res = ::write(m_fdPipeOut, b.getRawData() + off, len);
if(res < 0)
throw xIOException(_T("Cannot write on pipe!"),errno);
len -= res;
}
#endif
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
int xPipeInputStream::available()
{
if (isClosed())
return false;
#ifdef XTK_OS_WINDOWS
DWORD nAvailable;
//it works with anon pipes as well
DWORD rc = ::PeekNamedPipe
(
m_hPipeIn, // handle
NULL, 0, // ptr to buffer and its size
NULL, // [out] bytes read
&nAvailable, // [out] bytes available
NULL // [out] bytes left
);
if (!rc)
return 0;
return (int)nAvailable;
#elif defined(XTK_OS_UNIX)
// check if there is any input available
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(m_fdPipeIn, &readfds);
if(::select(m_fdPipeIn + 1, &readfds, NULL, NULL, &tv) != 1)
return 0;
return 1;
#endif
}
//------------------------------------------------------------
ofxPolyline ofxPolyline::getResampledAndVerticesBySpacing(float spacing) {
// Get resampled points while keeping vertices
ofxPolyline polyline;
polyline.setStrokeLinecap(getStrokeLinecap());
polyline.setStrokeLinejoin(getStrokeLinejoin());
float totalLength = getPerimeter();
int currentIndex = 1;
ofVec2f prevPoint = ofVec2f(FLT_MAX, FLT_MAX);
for(float f=0; f<totalLength; f += spacing) {
float index = getIndexAtLength(f);
while (index > currentIndex) {
ofVec2f newPoint = (*this)[currentIndex];
// Don't add if this point is very close to the prev point
if (!newPoint.match(prevPoint)) {
polyline.lineTo(newPoint);
prevPoint = newPoint;
}
currentIndex++;
}
ofVec2f newPoint = getPointAtLength(f);
// Don't add if this point is very close to the prev point
if (!newPoint.match(prevPoint)) {
polyline.lineTo(newPoint);
prevPoint = newPoint;
}
}
if(!isClosed()) {
if(polyline.size() > 0) {
polyline[polyline.size()-1] = (*this)[size()-1];
}
polyline.setClosed(false);
} else {
polyline.setClosed(true);
}
return polyline;
}
/**
* Updates the tangents at the start and end to make the spline periodic.
*/
void RSpline::updateTangentsPeriodic() {
if (!isValid() || !isClosed()) {
qWarning() << "RSpline::updateTangentsPeriodic(): "
"spline not valid or not closed";
}
// TODO: tangent support:
// RVector lStartTangent = tangentStart;
// RVector lEndTangent = tangentEnd;
unsetTangents();
double tangent1 = getDirection1();
double tangent2 = RMath::getNormalizedAngle(getDirection2() + M_PI);
RVector v1 = RVector::createPolar(1.0, tangent1);
RVector v2 = RVector::createPolar(1.0, tangent2);
RVector t = (v1 + v2).getNormalized();
// TODO: tangent support:
// RVector t1 = t;
// RVector t2 = t;
// t1.valid = lStartTangent.valid;
// t2.valid = lEndTangent.valid;
// if (!lStartTangent.isValid()) {
// setTangentAtStart(t1);
// }
// else {
// setTangentAtStart(lStartTangent);
// }
// if (!lEndTangent.isValid()) {
// setTangentAtEnd(t2);
// }
// else {
// setTangentAtEnd(lEndTangent);
// }
setTangents(t, t);
}
void MainWindow::on_startButton_clicked()
{
row = ui->tableProvider->rowCount();
column = ui->tableCustomer->columnCount();
fillProviders();
fillCustomers();
fillTariff();
if (isClosed())
{
createPlan();
findUV();
printUV();
while (!planIsGood()) {
findBadCell();
findCycle();
findMinAndBuildNewPlan();
findUV();
printUV();
};
};
printPlan();
}
void MediaSource::onReadyStateChange(const AtomicString& oldState, const AtomicString& newState)
{
if (isOpen()) {
scheduleEvent(eventNames().sourceopenEvent);
return;
}
if (oldState == openKeyword() && newState == endedKeyword()) {
scheduleEvent(eventNames().sourceendedEvent);
return;
}
ASSERT(isClosed());
m_activeSourceBuffers->clear();
// Clear SourceBuffer references to this object.
for (auto& buffer : *m_sourceBuffers)
buffer->removedFromMediaSource();
m_sourceBuffers->clear();
scheduleEvent(eventNames().sourcecloseEvent);
}
QDebug ConsoleAppender::debug(QDebug &rDebug) const
{
QString layout_name;
if (layout())
layout_name = layout()->name();
QString target;
if (mTarget == STDOUT_TARGET)
target = QLatin1String("STDOUT");
else
target = QLatin1String("STDERR");
rDebug.nospace() << "ConsoleAppender("
<< "name:" << name() << " "
<< "filter:" << firstFilter() << " "
<< "isactive:" << isActive() << " "
<< "isclosed:" << isClosed() << " "
<< "layout:" << layout_name << " "
<< "target:" << target << " "
<< "referencecount:" << referenceCount() << " "
<< "threshold:" << threshold().toString()
<< ")";
return rDebug.space();
}
void MediaSource::onReadyStateChange(const AtomicString& oldState, const AtomicString& newState)
{
if (isOpen()) {
scheduleEvent(eventNames().sourceopenEvent);
return;
}
if (oldState == openKeyword() && newState == endedKeyword()) {
scheduleEvent(eventNames().sourceendedEvent);
return;
}
ASSERT(isClosed());
m_activeSourceBuffers->clear();
// Clear SourceBuffer references to this object.
for (unsigned long i = 0, length = m_sourceBuffers->length(); i < length; ++i)
m_sourceBuffers->item(i)->removedFromMediaSource();
m_sourceBuffers->clear();
scheduleEvent(eventNames().sourcecloseEvent);
}
//----------------------------------------
void ofxBox2dEdge::create(b2World * b2dworld) {
bFlagShapeUpdate = false;
if(size() < 2) {
printf("need at least 3 points\n");
return;
}
if (body != NULL) {
b2dworld->DestroyBody(body);
body = NULL;
}
// create the body from the world (1)
b2BodyDef bd;
bd.type = density <= 0.0 ? b2_staticBody : b2_dynamicBody;
body = b2dworld->CreateBody(&bd);
vector<ofPoint>&pts = ofPolyline::getVertices();
for(int i=1; i<(int)size(); i++) {
b2EdgeShape edge;
edge.Set(screenPtToWorldPt(pts[i-1]), screenPtToWorldPt(pts[i]));
body->CreateFixture(&edge, density);
}
mesh.clear();
mesh.setUsage(body->GetType()==b2_staticBody?GL_STATIC_DRAW:GL_DYNAMIC_DRAW);
mesh.setMode(OF_PRIMITIVE_LINE_STRIP);
for(int i=0; i<(int)size(); i++) {
mesh.addVertex(ofVec3f(pts[i].x, pts[i].y));
}
// Temporary hack to ensure it's flagged as changed, until we
// switch to OF 0.8.0.
setClosed(isClosed());
alive = true;
}
void WebKitMediaSource::removeSourceBuffer(WebKitSourceBuffer* buffer, ExceptionCode& ec)
{
// 3.1 http://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#dom-removesourcebuffer
// 1. If sourceBuffer is null then throw an INVALID_ACCESS_ERR exception and
// abort these steps.
if (!buffer) {
ec = INVALID_ACCESS_ERR;
return;
}
// 2. If sourceBuffers is empty then throw an INVALID_STATE_ERR exception and
// abort these steps.
if (isClosed() || !m_sourceBuffers->length()) {
ec = INVALID_STATE_ERR;
return;
}
// 3. If sourceBuffer specifies an object that is not in sourceBuffers then
// throw a NOT_FOUND_ERR exception and abort these steps.
// 6. Remove sourceBuffer from sourceBuffers and fire a removesourcebuffer event
// on that object.
if (!m_sourceBuffers->remove(buffer)) {
ec = NOT_FOUND_ERR;
return;
}
// 7. Destroy all resources for sourceBuffer.
m_activeSourceBuffers->remove(buffer);
// 4. Remove track information from audioTracks, videoTracks, and textTracks for all tracks
// associated with sourceBuffer and fire a simple event named change on the modified lists.
// FIXME(91649): support track selection
// 5. If sourceBuffer is in activeSourceBuffers, then remove it from that list and fire a
// removesourcebuffer event on that object.
// FIXME(91649): support track selection
}
Position
PositionVector::getCentroid() const {
PositionVector tmp = *this;
if (!isClosed()) { // make sure its closed
tmp.push_back(tmp[0]);
}
const int endIndex = (int)tmp.size() - 1;
SUMOReal div = 0; // 6 * area including sign
SUMOReal x = 0;
SUMOReal y = 0;
if (tmp.area() != 0) { // numerical instability ?
// http://en.wikipedia.org/wiki/Polygon
for (int i = 0; i < endIndex; i++) {
const SUMOReal z = tmp[i].x() * tmp[i + 1].y() - tmp[i + 1].x() * tmp[i].y();
div += z; // area formula
x += (tmp[i].x() + tmp[i + 1].x()) * z;
y += (tmp[i].y() + tmp[i + 1].y()) * z;
}
div *= 3; // 6 / 2, the 2 comes from the area formula
return Position(x / div, y / div);
} else {
// compute by decomposing into line segments
// http://en.wikipedia.org/wiki/Centroid#By_geometric_decomposition
SUMOReal lengthSum = 0;
for (int i = 0; i < endIndex; i++) {
SUMOReal length = tmp[i].distanceTo(tmp[i + 1]);
x += (tmp[i].x() + tmp[i + 1].x()) * length / 2;
y += (tmp[i].y() + tmp[i + 1].y()) * length / 2;
lengthSum += length;
}
if (lengthSum == 0) {
// it is probably only one point
return tmp[0];
}
return Position(x / lengthSum, y / lengthSum);
}
}
//----------------------------------------
void ofxBox2dPolygon::triangulatePoly(float resampleAmt, int nPointsInside) {
triangles.clear();
bool wasClosed = isClosed();
if(size() > 0) {
// copy over the points into a polyline
ofPolyline polyOutline;
ofPolyline newPoly;
// make sure to close the polyline and then
// simplify and resample by spacing...
setClosed(true);
if(!bIsSimplified) simplify();
newPoly = getResampledBySpacing(resampleAmt);
// save the outline...
polyOutline = newPoly;
// add some random points inside then
// triangulate the polyline...
if(nPointsInside!=-1) addRandomPointsInside(newPoly, nPointsInside);
triangles = triangulatePolygonWithOutline(newPoly, polyOutline);
// clear();
ofPolyline::clear();
mesh.clear();
if(wasClosed) ofPolyline::setClosed(wasClosed);
// now add back into polyshape
for (size_t i=0; i<newPoly.size(); i++) {
addVertex(newPoly[i]);
}
}
bIsTriangulated = true;
}
// @mfunc Close this <c OMFile>, any unsaved changes are discarded.
// @precondition <f isOpen()>
// @postcondition <f !isOpen()>
// @postcondition <f isClosed()>
void OMFile::close(void)
{
TRACE("OMFile::close");
PRECONDITION("Open", isOpen());
PRECONDITION("Valid root", _root != 0);
_root->close();
_rootStore->close();
if (isValid()) {
OMStoredObjectFactory* factory = findFactory(_encoding);
ASSERT("Recognized file encoding", factory != 0);
factory->close(this);
}
_rootStore = 0; // We don't own _rootStore
_root->detach();
delete _root;
_root = 0;
_isOpen = false;
_isClosed = true;
POSTCONDITION("Closed", isClosed());
POSTCONDITION("Closed", !isOpen());
}
double QgsLineStringV2::vertexAngle( const QgsVertexId& vertex ) const
{
if ( vertex.vertex == 0 || vertex.vertex >= ( numPoints() - 1 ) )
{
if ( isClosed() )
{
double previousX = mX.at( numPoints() - 1 );
double previousY = mY.at( numPoints() - 1 );
double currentX = mX.at( 0 );
double currentY = mY.at( 0 );
double afterX = mX.at( 1 );
double afterY = mY.at( 1 );
return QgsGeometryUtils::averageAngle( previousX, previousY, currentX, currentY, afterX, afterY );
}
else if ( vertex.vertex == 0 )
{
return QgsGeometryUtils::linePerpendicularAngle( mX.at( 0 ), mY.at( 0 ), mX.at( 1 ), mY.at( 1 ) );
}
else
{
int a = numPoints() - 2;
int b = numPoints() - 1;
return QgsGeometryUtils::linePerpendicularAngle( mX.at( a ), mY.at( a ), mX.at( b ), mY.at( b ) );
}
}
else
{
double previousX = mX.at( vertex.vertex - 1 );
double previousY = mY.at( vertex.vertex - 1 );
double currentX = mX.at( vertex.vertex );
double currentY = mY.at( vertex.vertex );
double afterX = mX.at( vertex.vertex + 1 );
double afterY = mY.at( vertex.vertex + 1 );
return QgsGeometryUtils::averageAngle( previousX, previousY, currentX, currentY, afterX, afterY );
}
}
protocol::TMHello
buildHello (uint256 const& sharedValue, Application& app)
{
protocol::TMHello h;
Blob vchSig;
app.getLocalCredentials ().getNodePrivate ().signNodePrivate (
sharedValue, vchSig);
h.set_protoversion (to_packed (BuildInfo::getCurrentProtocol()));
h.set_protoversionmin (to_packed (BuildInfo::getMinimumProtocol()));
h.set_fullversion (BuildInfo::getFullVersionString ());
h.set_nettime (app.getOPs ().getNetworkTimeNC ());
h.set_nodepublic (app.getLocalCredentials ().getNodePublic (
).humanNodePublic ());
h.set_nodeproof (&vchSig[0], vchSig.size ());
// h.set_ipv4port (portNumber); // ignored now
h.set_testnet (false);
// We always advertise ourselves as private in the HELLO message. This
// suppresses the old peer advertising code and allows PeerFinder to
// take over the functionality.
h.set_nodeprivate (true);
auto const closedLedger = app.getLedgerMaster().getClosedLedger();
if (closedLedger && closedLedger->isClosed ())
{
uint256 hash = closedLedger->getHash ();
h.set_ledgerclosed (hash.begin (), hash.size ());
hash = closedLedger->getParentHash ();
h.set_ledgerprevious (hash.begin (), hash.size ());
}
return h;
}
MediaSource::~MediaSource()
{
LOG(MediaSource, "MediaSource::~MediaSource %p", this);
ASSERT(isClosed());
}
bool MediaSource::canSuspendForDocumentSuspension() const
{
return isClosed() && !m_asyncEventQueue.hasPendingEvents();
}
