virtual void checkedFetch(size_type number, const std::string& key, const std::string& expectedValue)
{
DBT keyDBT;
keyDBT.data = (void*)key.c_str();
keyDBT.size = key.size();
DBT retrievedValueDBT;
if (db_->get(db_, &keyDBT, &retrievedValueDBT, 0) == -1) {
RAISE_BENCHMARK_EXCEPTION("db_->get failed (number=%u, %s): error=%u", number, keyToString(key), errno);
}
boost::string_ref actualValue(static_cast<char*>(retrievedValueDBT.data), retrievedValueDBT.size);
if (expectedValue != actualValue) {
RAISE_BENCHMARK_EXCEPTION("unexpected value for key number %u", number);
}
}
sExpression *evalIf(sList *arguments, sEnvironment *env){
sExpression *temp = cdr(arguments);
if(isList(temp)){
sList *args = toList(temp);
sExpression *predicate;
if(LAZY_EVAL){
predicate = actualValue(car(args), env);
}else{
predicate = eval(car(args), env);
}
sExpression *trueExp = car(toList(cdr(args)));
sExpression *falseExp = car(toList(cdr(toList(cdr(args)))));
if(isTrue(predicate)){
return eval(trueExp, env);
}else{
return eval(falseExp, env);
}
}
return &sNull;
}
sExpression *eval(sExpression *exp, sEnvironment *env){
/* ------------------atom-----------------------*/
/* 1, 10, false, null, "abc" */
if(isSelfEval(exp))
{
return exp;
}
/* a symbol */
else if(isVariable(exp, env))
{
return lookupVariable(toSymb(exp), env);
}
/* ------------------list-----------------------*/
/* (quote blur blur) */
else if(isQuoted(exp))
{
return textOfQuoted(exp);
}
/* (set! name value) */
else if(isAssignment(exp))
{
return evalAssignment(exp, env);
}
/* (define name value) */
else if(isDefinition(exp))
{
return evalDefine(exp, env);
}
/* (define-syntax name ...) */
else if(isDefinitionSyntax(exp))
{
return evalDefineSyntax(exp, env);
}
/* (if blur blur blur) */
else if(isIf(exp))
{
return evalIf(toList(exp), env);
}
/* (lambda (args) (body)) */
else if(isLambdaConst(exp))
{
sList *body;
sList *param = toList( cadr(toList(exp)));
sExpression *temp = cdr(toList( cdr(toList(exp))));
if(isList(temp)){
body = toList(temp);
}else{
body = toList(cons(temp, &sNull));
}
return newLambda(param, body, env);
}
/* (syntax blur blur) syntax rule */
else if(isSymbol(car(toList(exp))) && isSyntaxRule(eval(car(toList(exp)), env)))
{
sExpression *exp2 = evalSyntaxRule(toSyntax(eval(car(toList(exp)), env)), exp);
return eval(exp2, env);
}
/* the other list (x . y) */
else if(isApplication(exp))
{
if(LAZY_EVAL){
sExpression *proexp = actualValue(operator(toList(exp)), env);
if(isLambdaType(proexp) || isPrimitiveProc(proexp)){
sExpression *operand = operands(toList(exp));
return applyLazly(proexp, operand, env);
}
}else{
sExpression *proexp = eval(operator(toList(exp)), env);
if(isLambdaType(proexp) || isPrimitiveProc(proexp)){
sExpression *operand = operands(toList(exp));
sExpression *arguments = listOfValues(operand, env);
return apply(proexp, arguments, env);
}
}
}
return &sError;
}
bool CameraBinExposure::setValue(ExposureParameter parameter, const QVariant& value)
{
QVariant oldValue = actualValue(parameter);
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
gst_photography_set_ev_compensation(m_session->photography(), value.toReal());
break;
case QCameraExposureControl::ISO:
gst_photography_set_iso_speed(m_session->photography(), value.toInt());
break;
case QCameraExposureControl::Aperture:
gst_photography_set_aperture(m_session->photography(), guint(value.toReal()*1000000));
break;
case QCameraExposureControl::ShutterSpeed:
gst_photography_set_exposure(m_session->photography(), guint(value.toReal()*1000000));
break;
case QCameraExposureControl::ExposureMode:
{
QCameraExposure::ExposureMode mode = QCameraExposure::ExposureMode(value.toInt());
GstSceneMode sceneMode;
gst_photography_get_scene_mode(m_session->photography(), &sceneMode);
switch (mode) {
case QCameraExposure::ExposureManual:
sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_MANUAL;
break;
case QCameraExposure::ExposurePortrait:
sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT;
break;
case QCameraExposure::ExposureSports:
sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT;
break;
case QCameraExposure::ExposureNight:
sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT;
break;
case QCameraExposure::ExposureAuto:
sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO;
break;
default:
break;
}
gst_photography_set_scene_mode(m_session->photography(), sceneMode);
break;
}
default:
return false;
}
if (!qFuzzyCompare(m_requestedValues.value(parameter).toReal(), value.toReal())) {
m_requestedValues[parameter] = value;
emit requestedValueChanged(parameter);
}
QVariant newValue = actualValue(parameter);
if (!qFuzzyCompare(oldValue.toReal(), newValue.toReal()))
emit actualValueChanged(parameter);
return true;
}
