void DatabaseSync::runTransaction(PassOwnPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& exceptionState)
{
ASSERT(m_executionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
setLastErrorMessage("unable to start a transaction from within a transaction");
exceptionState.throwUninformativeAndGenericDOMException(SQLDatabaseError);
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
transaction->begin(exceptionState);
if (exceptionState.hadException()) {
rollbackTransaction(transaction);
return;
}
transaction->execute(exceptionState);
if (exceptionState.hadException()) {
rollbackTransaction(transaction);
return;
}
transaction->commit(exceptionState);
if (exceptionState.hadException()) {
rollbackTransaction(transaction);
return;
}
setLastErrorMessage("");
}
bool TypeCommand::execute()
{
// now try and extract the var symbol
std::string symbol;
if(!m_func.getValueA<decltype(symbol)>(symbol, m_sharedCache)) {
setLastErrorMessage("type: couldn't determine argument");
return false;
}
// determine var key
std::string key;
if(!m_func.getValueB<decltype(key)>(key, m_sharedCache)) {
setLastErrorMessage("type: couldn't determine var key");
return false;
}
// determine type
auto type = m_sharedCache->getType(symbol);
if(!type) {
setLastErrorMessage("type: couldn't determine type");
return false;
}
m_sharedCache->setVar(key, getType(*type), Type::String);
return true;
}
bool RandomCommand::execute()
{
if(m_varName.empty()) {
setLastErrorMessage("random: var name empty. Can't continue.");
return false;
}
static std::default_random_engine re(m_r());
if (m_type == "int") {
int64_t a;
if (VarExtractor::trySingleIntExtraction(m_func.paramB, a, m_sharedCache)) {
using Dist = std::uniform_int_distribution<int64_t>;
static Dist uid {};
auto output = uid(re, Dist::param_type{0, a});
m_sharedCache->setVar(m_varName, output, Type::Int);
return true;
}
} else if (m_type == "real") {
double d;
if (VarExtractor::trySingleRealExtraction(m_func.paramB, d, m_sharedCache)) {
using Dist = std::uniform_real_distribution<double>;
static Dist udd {};
auto output = udd(re, Dist::param_type{0, d});
m_sharedCache->setVar(m_varName, output, Type::Real);
return true;
}
}
setLastErrorMessage("random: bad type.");
return false;
}
void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassOwnPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionState& exceptionState)
{
ASSERT(m_executionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
reportChangeVersionResult(1, SQLError::DATABASE_ERR, 0);
setLastErrorMessage("unable to changeVersion from within a transaction");
exceptionState.throwUninformativeAndGenericDOMException(SQLDatabaseError);
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
transaction->begin(exceptionState);
if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
String actualVersion;
if (!getVersionFromDatabase(actualVersion)) {
reportChangeVersionResult(2, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
return;
}
if (actualVersion != oldVersion) {
reportChangeVersionResult(3, SQLError::VERSION_ERR, 0);
setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
exceptionState.throwDOMException(VersionError, SQLError::versionErrorMessage);
return;
}
transaction->execute(exceptionState);
if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
if (!setVersionInDatabase(newVersion)) {
reportChangeVersionResult(4, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
return;
}
transaction->commit(exceptionState);
if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
setCachedVersion(oldVersion);
return;
}
reportChangeVersionResult(0, -1, 0); // OK
setExpectedVersion(newVersion);
setLastErrorMessage("");
}
void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionCode& ec)
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
reportChangeVersionResult(1, SQLException::DATABASE_ERR, 0);
setLastErrorMessage("unable to changeVersion from within a transaction");
ec = SQLException::DATABASE_ERR;
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
if ((ec = transaction->begin())) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
String actualVersion;
if (!getVersionFromDatabase(actualVersion)) {
reportChangeVersionResult(2, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
ec = SQLException::UNKNOWN_ERR;
return;
}
if (actualVersion != oldVersion) {
reportChangeVersionResult(3, SQLException::VERSION_ERR, 0);
setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
ec = SQLException::VERSION_ERR;
return;
}
if ((ec = transaction->execute())) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
if (!setVersionInDatabase(newVersion)) {
reportChangeVersionResult(4, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
ec = SQLException::UNKNOWN_ERR;
return;
}
if ((ec = transaction->commit())) {
ASSERT(!lastErrorMessage().isEmpty());
setCachedVersion(oldVersion);
return;
}
reportChangeVersionResult(0, -1, 0); // OK
setExpectedVersion(newVersion);
setLastErrorMessage("");
}
bool ListAddTokenCommand::execute()
{
std::string varName;
if(!m_func.getValueB<std::string>(varName, m_sharedCache)) {
setLastErrorMessage("list_add: couldn't parse variable name");
return false;
}
if(tryWithSymbolList(varName)) { return true; }
setLastErrorMessage("list_add: no list found");
return false;
}
bool TieCommand::execute()
{
ValueArray paramArray;
if(!m_func.getValueB<ValueArray>(paramArray, m_sharedCache)) {
setLastErrorMessage("tie: error");
return false;
}
std::vector<List> lists;
for(auto const & v : paramArray) {
// Try symbol
std::string symbol;
if(VarExtractor::tryAnyCast(symbol, v)) {
auto const list = m_sharedCache->getVar<List>(symbol, Type::List);
if(list) {
lists.push_back(*list);
continue;
}
}
// Try raw list
List list;
if(VarExtractor::tryAnyCast(list, v)) {
lists.push_back(list);
continue;
}
}
if(lists.empty()) {
setLastErrorMessage("tie: no lists");
return false;
}
auto current = std::begin(lists);
auto length = current->size();
++current;
for(; current != std::end(lists); ++current) {
auto const listLength = current->size();
if(length != listLength) {
setLastErrorMessage("tie: lists different lengths");
return false;
}
}
//m_sharedCache->setVar(resultName, matchesResult, Type::Bool);
return true;
}
void DatabaseSync::rollbackTransaction(PassRefPtr<SQLTransactionSync> transaction)
{
ASSERT(!lastErrorMessage().isEmpty());
transaction->rollback();
setLastErrorMessage("");
return;
}
MSCResult convertExceptionsToResultCode(F functor)
{
try {
functor();
return MSCR_Success;
} catch (mcore::Exception& ex) {
setLastErrorMessage(ex.what());
return ex.code();
} catch (std::exception& ex) {
setLastErrorMessage(ex.what());
return MSCR_Unknown;
} catch (...) {
setLastErrorMessage("Unknown exception thrown.");
return MSCR_Unknown;
}
}
RandomCommand::RandomCommand(Function &func_,
SharedCacheStack const &sharedCache,
OptionalOutputStream const &output)
: Command(func_, sharedCache, output)
, m_type()
, m_varName()
, m_r()
{
// random:int 5 -> a;
// random:real 3.14 -> d;
if(VarExtractor::tryAnyCast(m_type, m_func.paramA)) {
if(!VarExtractor::tryAnyCast(m_varName, m_func.paramC)) {
setLastErrorMessage("random: problem determining var name");
}
} else {
setLastErrorMessage("random: problem determining random type");
}
}
void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionCode& ec)
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
setLastErrorMessage("unable to start a transaction from within a transaction");
ec = SQLException::DATABASE_ERR;
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
if ((ec = transaction->begin()) || (ec = transaction->execute()) || (ec = transaction->commit())) {
ASSERT(!lastErrorMessage().isEmpty());
transaction->rollback();
}
setLastErrorMessage("");
}
void QTweetGeoReverseGeoCode::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetPlace> places = QTweetConvert::variantToPlaceList(json);
emit parsedPlaces(places);
} else {
qDebug() << "QTweetGeoReverseGeoCode parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
void QTweetAccountVerifyCredentials::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetUser user = QTweetConvert::variantMapToUserInfo(json.toMap());
emit parsedUser(user);
} else {
qDebug() << "QTweetAccountVerifyCredentials parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
void QTweetListCreate::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetList list = QTweetConvert::variantMapToTweetList(json.toMap());
emit parsedList(list);
} else {
qDebug() << "QTweetListCreate json parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
void QTweetFriendshipDestroy::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetUser user = QTweetConvert::variantMapToUserInfo(json.toMap());
emit parsedUser(user);
} else {
qDebug() << "QTweetFriendshipCreate parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
void QTweetDirectMessageDestroy::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetDMStatus dm = QTweetConvert::variantMapToDirectMessage(json.toMap());
emit parsedDirectMessage(dm);
} else {
qDebug() << "QTweetDirectMessageDestroy parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
bool UBWaveRecorder::stop()
{
mIsRecording = false;
if (waveInStop(mWaveInDevice) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot stop wave in device ");
return false;
}
return true;
}
void QTweetDirectMessagesSent::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetDMStatus> directMessages = QTweetConvert::variantToDirectMessagesList(json);
emit parsedDirectMessages(directMessages);
} else {
qDebug() << "QTweetDirectMessagesSent parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
/// parses the given grammar file
/// @param file the file to read
/// @return the language grammar or 0 on error
TextGrammar* TmLanguageParser::parse(const QString& fileName)
{
QFile file(fileName);
if( file.open( QIODevice::ReadOnly ) ) {
TextGrammar* result = parse( &file );
file.close();
return result;
} else {
setLastErrorMessage( file.errorString() );
return 0;
}
}
void QTweetStatusRetweet::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetStatus status = QTweetConvert::variantMapToStatus(json.toMap());
emit postedRetweet(status);
} else {
qDebug() << "QTweetStatusRetweet JSON parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
bool FileAppendBytesCommand::execute()
{
std::string filename;
if(VarExtractor::trySingleStringExtraction(m_func.paramB, filename, m_sharedCache)) {
ByteArray value;
if(!VarExtractor::trySingleArrayExtraction(m_func.paramA, value, m_sharedCache, Type::ByteArray)) {
setLastErrorMessage("file_append_bytes: problem with bytes array");
return false;
}
// open the file and write data
writeBytes(filename,
reinterpret_cast<char const*>(&value.front()),
value.size(),
std::ios::binary | std::ios::app);
} else {
setLastErrorMessage("file_append_bytes: couldn't parse filename");
return false;
}
return true;
}
void QTweetMentions::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetStatus> statuses = QTweetConvert::variantToStatusList(json);
emit parsedStatuses(statuses);
} else {
qDebug() << "QTweetMentions JSON parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
bool UBWaveRecorder::close()
{
if (waveInReset(mWaveInDevice) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot reset wave in device ");
return false;
}
foreach(WAVEHDR* buffer, mWaveBuffers)
{
waveInUnprepareHeader(mWaveInDevice, buffer, sizeof(WAVEHDR));
delete [] buffer->lpData;
delete buffer;
}
OptionalList ListAddTokenCommand::getNewVAToken()
{
std::string token;
if(!m_func.getValueA<std::string>(token, m_sharedCache)) {
List va;
if(m_func.getValueA<List>(va, m_sharedCache)) {
return va;
}
} else {
auto result = m_sharedCache->getVar<List>(token, Type::List);
if(result) {
return *result;
}
}
setLastErrorMessage("list_add: problem getting new token");
return OptionalList();
}
OptionalString ListAddTokenCommand::getNewStringToken()
{
std::string token;
if(!m_func.getValueA<std::string>(token, m_sharedCache)) {
LiteralString literal;
if(m_func.getValueA<LiteralString>(literal, m_sharedCache)) {
return OptionalString(literal.literal);
}
} else {
auto result = m_sharedCache->getVar<std::string>(token, Type::String);
if(result) {
return OptionalString(*result);
}
}
setLastErrorMessage("list_add: problem getting new token");
return OptionalString();
}
bool UBWaveRecorder::start()
{
if (!mIsRecording)
{
mRecordingStartTime = QTime::currentTime();
mMsTimeStamp = 0;
mIsRecording = true;
}
if (waveInStart(mWaveInDevice) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot start wave in device ");
return false;
}
return true;
}
void QTweetListSubscriptions::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QVariantMap respMap = json.toMap();
QVariant listsVar = respMap["lists"];
QList<QTweetList> lists = QTweetConvert::variantToTweetLists(listsVar);
QString nextCursor = respMap["next_cursor_str"].toString();
QString prevCursor = respMap["previous_cursor_str"].toString();
emit parsedLists(lists, nextCursor, prevCursor);
} else {
qDebug() << "QTweetListSubscriptions json parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
void QTweetListSubscribers::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QVariantMap respMap = json.toMap();
QVariant userList = respMap["users"];
QList<QTweetUser> users = QTweetConvert::variantToUserInfoList(userList);
QString nextCursor = respMap["next_cursor_str"].toString();
QString prevCursor = respMap["previous_cursor_str"].toString();
emit parsedUsers(users, nextCursor, prevCursor);
} else {
qDebug() << "QTweetListSubscribers json parsing error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}
bool UBAudioQueueRecorder::init(const QString& waveInDeviceName)
{
if(mIsRecording)
{
setLastErrorMessage("Already recording ...");
return false;
}
OSStatus err = AudioQueueNewInput (&sAudioFormat, UBAudioQueueRecorder::audioQueueInputCallback,
this, 0, 0, 0, &mQueue);
if (err)
{
setLastErrorMessage(QString("Cannot acquire audio input %1").arg(err));
mQueue = 0;
close();
return false;
}
//qDebug() << "init with waveInDeviceName ..." << waveInDeviceName;
if (waveInDeviceName.length() > 0 && waveInDeviceName != "Default")
{
AudioDeviceID deviceID = deviceIDFromDeviceName(waveInDeviceName);
if (deviceID)
{
QString deviceUID = deviceUIDFromDeviceID(deviceID);
if (deviceUID.length() > 0)
{
CFStringRef sr = CFStringCreateWithCString(0, deviceUID.toUtf8().constData(), kCFStringEncodingUTF8);
err = AudioQueueSetProperty(mQueue, kAudioQueueProperty_CurrentDevice, &sr, sizeof(CFStringRef));
if (err)
{
setLastErrorMessage(QString("Cannot set audio input %1 (%2)").arg(waveInDeviceName).arg(err));
}
else
{
qDebug() << "recording with input" << waveInDeviceName;
}
}
else
{
setLastErrorMessage(QString("Cannot find audio input device UID with ID %1 (%2)").arg(deviceID).arg(err));
}
}
else
{
setLastErrorMessage(QString("Cannot find audio input with name %1 (%2)").arg(waveInDeviceName).arg(err));
}
}
UInt32 monitor = true;
err = AudioQueueSetProperty(mQueue, kAudioQueueProperty_EnableLevelMetering , &monitor, sizeof(UInt32));
if (err)
{
qWarning() << QString("Cannot set recording level monitoring %1").arg(err);
}
int nbBuffers = 6;
mSampleBufferSize = sAudioFormat.mSampleRate * sAudioFormat.mChannelsPerFrame
* 2 * mBufferLengthInMs / 1000; // 44.1 Khz * stereo * 16bit * buffer length
for (int i = 0; i < nbBuffers; i++)
{
AudioQueueBufferRef outBuffer;
err = AudioQueueAllocateBuffer(mQueue, mSampleBufferSize, &outBuffer);
if (err)
{
setLastErrorMessage(QString("Cannot allocate audio buffer %1").arg(err));
close();
return false;
}
mBuffers << outBuffer;
}
foreach(AudioQueueBufferRef buffer, mBuffers)
{
err = AudioQueueEnqueueBuffer(mQueue, buffer, 0, 0);
if (err)
{
setLastErrorMessage(QString("Cannot enqueue audio buffer %1").arg(err));
close();
return false;
}
}
bool UBWaveRecorder::init(const QString& waveInDeviceName)
{
UINT deviceID = WAVE_MAPPER;
if (waveInDeviceName.length() > 0)
{
int count = waveInGetNumDevs();
WAVEINCAPS caps;
for (int i = 0; i < count; i++)
{
if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR)
{
QString deviceName = QString:: fromUtf16(caps.szPname);
if (deviceName == waveInDeviceName)
{
deviceID = i;
break;
}
}
}
}
WAVEFORMATEX format;
format.cbSize = 0;
format.wFormatTag = WAVE_FORMAT_PCM;
format.nChannels = mNbChannels;
format.wBitsPerSample = mBitsPerSample;
format.nSamplesPerSec = mSampleRate;
format.nBlockAlign = format.nChannels * (format.wBitsPerSample / 8);
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
if (waveInOpen(&mWaveInDevice, deviceID, &format, (DWORD)waveInProc, (DWORD_PTR)this, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot open wave in device ");
return false;
}
int nbBuffers = 6;
int sampleBufferSize = 44100 * 2 * 2 * mBufferLengthInMs / 1000; // 44.1 Khz * stereo * 16bit * buffer length
for (int i = 0; i < nbBuffers; i++)
{
WAVEHDR* buffer = new WAVEHDR();
ZeroMemory(buffer, sizeof(WAVEHDR));
buffer->lpData = (LPSTR)new BYTE[sampleBufferSize];
ZeroMemory(buffer->lpData, sampleBufferSize);
buffer->dwBufferLength = sampleBufferSize;
buffer->dwFlags = 0;
if (waveInPrepareHeader(mWaveInDevice, buffer, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot prepare wave header");
return false;
}
if (waveInAddBuffer(mWaveInDevice, buffer, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot add buffer");
return false;
}
mWaveBuffers << buffer;
}
return true;
}
