/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#ifndef KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H
#define KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H
// Libraries includes
#include
#include
#include
#include
#include
// Namespace includes
#include "CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer.h"
#include "CSPARQLResultStreamingController.h"
#include "CSPARQLResultBufferWriteData.h"
// Other includes
#include "Reasoner/Query/CVariableBindingsAnswersResult.h"
#include "Reasoner/Query/CBooleanQueryResult.h"
#include "Reasoner/Query/CComplexAssertionsIndividualVariablesAnsweringQuery.h"
#include "Reasoner/Query/CVariableBindingsAnswersStreamingHandler.h"
#include "Reasoner/Query/CVariableBindingsAnswersConcurrentStreamingHandler.h"
#include "Reasoner/Query/CVariableBindingsAnswersStreamingResult.h"
#include "Reasoner/Query/CRedlandRasqalBGPsCompositionQuery.h"
#include "Control/Command/Instructions/CQueryCommandProvider.h"
#include "Control/Command/CCommand.h"
// Logger includes
#include "Logger/CLogger.h"
using namespace Konclude::Logger;
namespace Konclude {
using namespace Reasoner::Query;
namespace Control {
using namespace Command;
using namespace Command::Instructions;
namespace Interface {
namespace SPARQL {
class CSPARQLResultConcurrentStreamingDataBufferReciever {
public:
virtual CSPARQLResultConcurrentStreamingDataBufferReciever* transferConcurrentBuffers(QList& bufferList, cint64& bufferSize) = 0;
};
/*!
*
* \class CSPARQLResultStreamingData
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CSPARQLResultStreamingData : public CQueryCommandProvider, public CVariableBindingsAnswersStreamingHandler, public CSPARQLResultConcurrentStreamingDataBufferReciever {
// public methods
public:
//! Constructor
CSPARQLResultStreamingData(CQueryCommandProvider* queryProvider, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
CSPARQLResultStreamingData(CQuery* query, cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
//! Destructor
virtual ~CSPARQLResultStreamingData();
virtual CQuery *getQuery();
virtual CCommand *getCommand();
virtual bool initResultStreaming(const QStringList& varNames);
virtual CVariableBindingsAnswersStreamingHandler* streamResultVariableBindings(CVariableBindingsAnswerResult* varBindings, cint64 cardinality = 1);
virtual bool streamingFlush();
virtual CVariableBindingsAnswersStreamingHandler* finishResultStreaming();
virtual CSPARQLResultStreamingData* handleQueryResult(CQuery* query, CQueryResult* queryResult);
virtual CSPARQLResultStreamingData* handleQueryError(CQuery* query, const QString& error);
CSPARQLResultStreamingData* finalize();
QList takeWriteableBuffers();
cint64 getWriteableBufferSize();
cint64 getWriteableBufferCount();
cint64 getSequenceNumber();
virtual CVariableBindingsAnswersConcurrentStreamingHandler* getConcurrentStreamingHandler();
virtual CVariableBindingsAnswersStreamingHandler* releaseConcurrentStreamingHandler(CVariableBindingsAnswersConcurrentStreamingHandler* handler);
virtual CSPARQLResultConcurrentStreamingDataBufferReciever* transferConcurrentBuffers(QList& bufferList, cint64& bufferSize);
// protected methods
protected:
class CSPARQLResultConcurrentStreamingData : public CVariableBindingsAnswersConcurrentStreamingHandler {
public:
CSPARQLResultConcurrentStreamingData(cint64 bufferSize, cint64 maxBufferSize, QStringList* varNames, bool* serialize, CSPARQLResultConcurrentStreamingDataBufferReciever* reciever) {
mBufferSize = bufferSize;
mMaxBufferSize = maxBufferSize;
mVarNames = varNames;
mSerializer = nullptr;
mUsedBufferSize = 0;
mSerialize = serialize;
mReciever = reciever;
mMaxBufferCollectingCount = 10;
}
~CSPARQLResultConcurrentStreamingData() {
if (mSerializer) {
delete mSerializer;
}
}
CVariableBindingsAnswersConcurrentStreamingHandler* concurrentlyStreamResultVariableBindings(CVariableBindingsAnswerResult* varBindings, cint64 cardinality) {
if (*mSerialize) {
if (!mSerializer) {
QByteArray* bufferArray = new QByteArray();
bufferArray->reserve(mBufferSize + 10000);
mSerializer = new CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer(bufferArray, this);
}
mSerializer->addResultStreamingBindingToTemporaryBuffer(*mVarNames, varBindings);
bool onlyVarBindWritten = false;
cint64 onlyVarBindCount = 0;
if (mSerializer->getBufferWrittenSize() <= 0) {
onlyVarBindWritten = true;
}
while (cardinality > 0) {
mSerializer->addTemporaryBuffer();
++onlyVarBindCount;
--cardinality;
if (mSerializer->getBufferWrittenSize() > mBufferSize) {
mBufferSize *= 2;
if (mBufferSize > mMaxBufferSize) {
mBufferSize = mMaxBufferSize;
}
cint64 bufferWriteCount = 1;
if (onlyVarBindWritten) {
while (cardinality > onlyVarBindCount) {
cardinality -= onlyVarBindCount;
++bufferWriteCount;
}
}
QByteArray* bufferArray = new QByteArray();
bufferArray->reserve(mBufferSize + 10000);
QByteArray* usedBuffer = mSerializer->updateWriteBuffer(bufferArray);
mUsedBufferSize += usedBuffer->size();
mUsedBufferList.append(CSPARQLResultBufferWriteData(bufferWriteCount, usedBuffer));
onlyVarBindWritten = true;
onlyVarBindCount = 0;
if (mUsedBufferList.size() >= mMaxBufferCollectingCount) {
mReciever->transferConcurrentBuffers(mUsedBufferList, mUsedBufferSize);
}
}
}
mSerializer->clearTemporaryBuffer();
}
return this;
}
bool hasData() {
return mSerializer && (mSerializer->getBufferWrittenSize() > 0 || mUsedBufferSize > 0);
}
CSPARQLResultConcurrentStreamingData* addBuffers(QList& bufferList, cint64& bufferSize) {
if (mSerializer && mSerializer->getBufferWrittenSize() > 0) {
QByteArray* usedBuffer = mSerializer->updateWriteBuffer(nullptr);
CSPARQLResultBufferWriteData usedBufferData(1, usedBuffer);
mUsedBufferSize += usedBuffer->size();
mUsedBufferList.append(usedBufferData);
}
bufferList.append(mUsedBufferList);
bufferSize += mUsedBufferSize;
return this;
}
CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer* mSerializer;
QList mUsedBufferList;
cint64 mUsedBufferSize;
cint64 mBufferSize;
cint64 mMaxBufferSize;
QStringList* mVarNames;
bool* mSerialize = nullptr;
CSPARQLResultConcurrentStreamingDataBufferReciever* mReciever;
cint64 mMaxBufferCollectingCount;
};
CSPARQLResultStreamingData* init(cint64 sequenceNumber, cint64 bufferSize, CSPARQLResultStreamingController* streamingController);
// protected variables
protected:
CSPARQLResultStreamingController* mStreamingController;
CSPARQLXMLAnswerStreamingPrecompiledByteArraySerializer* mSerializer;
CQueryCommandProvider* mQueryProvider;
CQuery* mQuery;
cint64 mSequenceNumber;
CVariableBindingsAnswersStreamingResult* mStreamingResult;
QStringList mVarNames;
cint64 mMaxBufferSize;
cint64 mBufferSize;
cint64 mInitialBufferSize;
bool mStreamingFinished;
bool mStreamingInitialized;
bool mFinalized;
bool mContinueSerialization;
cint64 mFlushId;
QList mUsedBufferList;
cint64 mUsedBufferSize;
bool mWritingScheduled;
cint64 mConcurrentFinishCount;
QMutex* mBufferMutex;
// private methods
private:
// private variables
private:
};
}; // end namespace SPARQL
}; // end namespace Interface
}; // end namespace Control
}; // end namespace Konclude
#endif // KONCLUDE_CONTROL_INTERFACE_OWLLINK_CSPARQLRESULTSTREAMINGDATA_H