void object::test<5>()
{
int id = 1;
int MAX_RECORD = 100;
st << utf("insert into some_table(id) values(:id)"), use(id);
ensure("no row", !se.last_exec());
se << utf(L"begin");
for (; id <= MAX_RECORD; ++id)
{
st.reset(true);
st.exec();
ensure("row", !se.last_exec());
}
se << utf(L"commit");
int id2;
st << utf(L"select id from some_table"), into(id2);
for (id = 1; st.exec(); ++id)
{
ensure("row", se.last_exec());
ensure_equals("id", id2, id);
}
ensure_equals("MAX_RECORD", id - 1, MAX_RECORD);
ensure_equals("MAX_RECORD", id2, MAX_RECORD);
}
void object::test<1>()
{
ensure("empty query", q.empty() );
q.sql(utf(L"qaz"));
ensure_equals("q.sql() == qaz", q.sql(), utf(L"qaz") );
}
void object::test<2>()
{
{
transaction t(se);
record r1(1, utf(L"Eugeny"), 566.24);
r1.insert(se);
t.commit();
}
ensure( "no active txn", !se.active_txn() );
int rows;
se << utf(L"select count(*) from some_table"), into(rows);
ensure_equals("commit", rows, 1);
}
void object::test<3>()
{
try
{
int id;
st << utf(L"select id from some_table"), into(id, utf(L"id_ZZZ"));
st.exec();
fail( "exception expected" );
}
catch(sqlitepp::exception const&)
{
ensure( "statement not prepared", !st.is_prepared() );
}
}
void object::test<2>()
{
record r1(1, utf(L"Egor"), 345.2);
r1.insert(se);
record r2;
st << utf(L"select id, name, salary from some_table"),
into(r2.salary, utf(L"salary")), into(r2.id, utf(L"id")), into(r2.name, utf(L"name"));
ensure( "row selected", st.exec() );
ensure("row", se.last_exec());
ensure_equals(r1, r2);
ensure("single row", !st.exec() );
}
void object::test<1>()
{
record r1(1, utf(L"Ignat"), 345.2);
r1.insert(se);
record r2;
st << utf(L"select * from some_table where id = 1"),
into(r2.id), into(r2.name), into(r2.salary);
ensure("select completed", st.exec());
ensure("row", se.last_exec());
ensure_equals(r1, r2);
ensure( "single row", !st.exec() );
}
void object::test<1>()
{
record recs[2] = { record(1, utf(L"Petya"), 123.45), record(2, utf(L"Vasya"), 678.90) };
// insert records
for (size_t i = 0; i < dimof(recs); ++i)
{
st << utf(L"insert into some_table values( :id, :name, :salary, NULL)"),
use(recs[i].id), use(recs[i].name), use(recs[i].salary);
ensure("row inserted", !st.exec() );
ensure("no data", !se.last_exec());
}
// count inserted record
int count;
se << utf(L"select count(*) from some_table"), into(count);
ensure("row", se.last_exec());
ensure_equals("row count", count, static_cast<int>(dimof(recs)) );
// check inserted records
record r;
st << utf(L"select id, name, salary from some_table"),
into(r.id, utf(L"id")), into(r.name, utf(L"name")), into(r.salary, utf(L"salary"));
for (count = 0; st.exec(); ++count)
{
ensure("row", se.last_exec());
ensure_equals(r, recs[count]);
}
ensure_equals("row count", count, static_cast<int>(dimof(recs)));
}
void object::test<3>()
{
try
{
int id;
st << utf(L"insert into some_table(id, name, salary) values( :id, '', 0)"),
use(id, utf(L"id_ZZZ"));
st.exec();
fail( "exception expected" );
}
catch (sqlitepp::no_such_column const&)
{
ensure( "statement not prepared", !st.is_prepared() );
}
}
void object::test<4>()
{
record r1(1, utf(L"Gosha"), 634.4);
r1.insert(se);
record r2;
st << utf(L"select * from some_table where id = 1"),
into(r2.id), into(r2.name), into(r2.salary), into(r2.data);
ensure("select completed", st.exec());
ensure("row", se.last_exec());
ensure_equals(r1, r2);
ensure("empty blob", r2.data.empty());
ensure( "single row", !st.exec() );
}
transaction::transaction(session& s, type t)
: s_(&s)
, do_rollback_(false)
{
if ( s_->active_txn() )
{
throw nested_txn_not_supported();
}
char const* begin_cmd;
switch ( t )
{
case deferred:
begin_cmd = "begin deferred";
break;
case immediate:
begin_cmd = "begin immediate";
break;
case exclusive:
begin_cmd = "begin exclusive";
break;
default:
assert(false && "unknown transaction type");
begin_cmd = "begin";
break;
}
*s_ << utf(begin_cmd);
s_->active_txn_ = this;
do_rollback_ = true;
}
int sceCccUTF8toUTF16(u32 dstAddr, u32 dstSize, u32 srcAddr)
{
const auto src = PSPConstCharPointer::Create(srcAddr);
auto dst = PSPWCharPointer::Create(dstAddr);
if (!dst.IsValid() || !src.IsValid())
{
ERROR_LOG(HLE, "sceCccUTF8toUTF16(%08x, %d, %08x): invalid pointers", dstAddr, dstSize, srcAddr);
return 0;
}
// Round dstSize down if it represents half a character.
const auto dstEnd = PSPWCharPointer::Create(dstAddr + (dstSize & ~1));
DEBUG_LOG(HLE, "sceCccUTF8toUTF16(%08x, %d, %08x)", dstAddr, dstSize, srcAddr);
UTF8 utf(src);
int n = 0;
while (u32 c = utf.next())
{
if (dst + UTF16LE::encodeUnits(c) >= dstEnd)
break;
dst += UTF16LE::encode(dst, c);
n++;
}
if (dst < dstEnd)
*dst++ = 0;
CBreakPoints::ExecMemCheck(srcAddr, false, utf.byteIndex(), currentMIPS->pc);
CBreakPoints::ExecMemCheck(dstAddr, true, dst.ptr - dstAddr, currentMIPS->pc);
return n;
}
void DrawBuffer::MeasureTextCount(int font, const char *text, int count, float *w, float *h) {
const AtlasFont &atlasfont = *atlas->fonts[font];
unsigned int cval;
float wacc = 0;
float maxX = 0.0f;
int lines = 1;
UTF8 utf(text);
while (true) {
if (utf.end())
break;
if (utf.byteIndex() >= count)
break;
cval = utf.next();
// Translate non-breaking space to space.
if (cval == 0xA0) {
cval = ' ';
}
if (cval == '\n') {
maxX = std::max(maxX, wacc);
wacc = 0;
lines++;
continue;
} else if (cval == '&' && utf.peek() != '&') {
// Ignore lone ampersands
continue;
}
const AtlasChar *c = atlasfont.getChar(cval);
if (c) {
wacc += c->wx * fontscalex;
}
}
if (w) *w = std::max(wacc, maxX);
if (h) *h = atlasfont.height * fontscaley * lines;
}
/// \brief Update Kalman filter
void UnscentedKalmanFilter::updateUKF(vnl_vector<double> u, vnl_vector<double> z)
{
// create Sigma points X for the current estimate distribution
vnl_matrix<double> X(N,2*N+1);
sigmas(x_hat, P_hat+Q, sqrt(C), X);
vnl_matrix<double> Dbg;
qDebug() << "X: ";
for( int i = 0; i<6; i++)
{
qDebug() << X(i,0) << " " << X(i,1) << " " << X(i,2) << " " << X(i,3) << " " << X(i,4) << " " << X(i,5) << " "
<< X(i,6) << " " << X(i,7) << " " << X(i,8) << " " << X(i,9) << " " << X(i,10) << " " << X(i,11)
<< " " << X(i,12);
}
// apply unscented transformation for process model
vnl_vector<double> x1(6);
vnl_matrix<double> X1(N,2*N+1), P1(N,N), X2(N,2*N+1);
utf(X, u, x1, X1, P1, X2);
// apply unscented transformation for observation model
vnl_vector<double> z1(M);
vnl_matrix<double> Z1(M,2*M+1), P2(M,M), Z2(M,2*M+1);
utg(X1, z1, Z1, P2, Z2);
// define transformated cross-covariance
vnl_matrix<double> WC(2*N+1,2*N+1,0.0);
WC.set_diagonal(Wc.get_row(0));
vnl_matrix<double> P12 = X2*WC*Z2.transpose();
// perform state update
K = P12*vnl_matrix_inverse<double>(P2);
x_hat = x1 + K*(z-z1);
// perform covariance update
P_hat = P1 - K*P12.transpose();
}
int sceCccUTF16toSJIS(u32 dstAddr, int dstSize, u32 srcAddr)
{
PSPWCharPointer src;
PSPCharPointer dst;
dst = dstAddr;
src = srcAddr;
if (!dst.IsValid() || !src.IsValid())
{
ERROR_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x): invalid pointers", dstAddr, dstSize, srcAddr);
return 0;
}
if (!ucs2jisTable.IsValid())
{
ERROR_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x): table not loaded", dstAddr, dstSize, srcAddr);
return 0;
}
DEBUG_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x)", dstAddr, dstSize, srcAddr);
UTF16LE utf(src);
int n = 0;
while (u32 c = utf.next())
{
dst += ShiftJIS::encode(dst, __CccUCStoJIS(c, errorSJIS));
n++;
}
return n;
}
std::string Window_Message::ParseCommandCode(int call_depth) {
int parameter;
bool is_valid;
// sub_code is used by chained arguments like \v[\v[1]]
// In that case sub_code contains the result from \v[1]
int sub_code = -1;
uint32_t cmd_char = *text_index;
if (std::distance(text_index, end) > 3 &&
*boost::next(text_index, 2) == utf('\\') &&
tolower(*boost::next(text_index, 3)) == utf('v')) {
++(++(++text_index));
// The result is an int value, str-to-int is safe in this case
std::stringstream ss;
ss << ParseCommandCode(++call_depth);
ss >> sub_code;
}
int sceCccUTF16toSJIS(u32 dstAddr, u32 dstSize, u32 srcAddr)
{
const auto src = PSPConstWCharPointer::Create(srcAddr);
auto dst = PSPCharPointer::Create(dstAddr);
if (!dst.IsValid() || !src.IsValid())
{
ERROR_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x): invalid pointers", dstAddr, dstSize, srcAddr);
return 0;
}
if (!ucs2jisTable.IsValid())
{
ERROR_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x): table not loaded", dstAddr, dstSize, srcAddr);
return 0;
}
const auto dstEnd = PSPCharPointer::Create(dstAddr + dstSize);
DEBUG_LOG(HLE, "sceCccUTF16toSJIS(%08x, %d, %08x)", dstAddr, dstSize, srcAddr);
UTF16LE utf(src);
int n = 0;
while (u32 c = utf.next())
{
if (dst + ShiftJIS::encodeUnits(c) >= dstEnd)
break;
dst += ShiftJIS::encode(dst, __CccUCStoJIS(c, errorSJIS));
n++;
}
if (dst < dstEnd)
*dst++ = 0;
CBreakPoints::ExecMemCheck(srcAddr, false, utf.shortIndex() * sizeof(uint16_t), currentMIPS->pc);
CBreakPoints::ExecMemCheck(dstAddr, true, dst.ptr - dstAddr, currentMIPS->pc);
return n;
}
void object::test<6>()
{
se << "insert into some_table values(:id, :name, :salary, NULL)",
use(1), use("zzz"), use(999);
se << "insert into some_table values(:id, :name, :salary, NULL)",
use(2), use("aaa"), use(111);
se << "insert into some_table values(:id, :name, :salary, NULL)",
use(3), use("ddd", utf(":name")), use(333);
se << "insert into some_table values(:id, :name, :salary, NULL)",
use(4), use("qqq", utf(":name")), use(222);
int count;
se << utf(L"select count(*) from some_table"), into(count);
ensure_equals("row count", count, 4);
}
void transaction::commit()
{
if ( s_ )
{
*s_ << utf("commit");
}
do_rollback_ = false;
}
void object::test<1>()
{
int rows;
ensure( "no active txn", !se.active_txn() );
{
transaction t(se);
ensure_equals( "this active txn", se.active_txn(), &t );
record r1(1, utf(L"Dima"), 566.24);
r1.insert(se);
se << utf(L"select count(*) from some_table"), into(rows);
ensure_equals("row inserted", rows, 1);
}
ensure( "no active txn", !se.active_txn() );
se << utf(L"select count(*) from some_table"), into(rows);
ensure_equals("rollback", rows, 0);
}
int CALLBACK ui_menu_font_ui::EnumFontFamiliesExProc(const LOGFONT *lpelfe, const TEXTMETRIC *lpntme, DWORD FontType, LPARAM lParam)
{
std::vector<std::string> *lpc = (std::vector<std::string>*)lParam;
std::string utf((char *)lpelfe->lfFaceName);
if (utf[0] != '@')
lpc->push_back(utf);
return 1;
}
bool
HippoHTTP::writeToStreamAsUTF8(IStream *stream,
WCHAR *str,
HippoHTTPAsyncHandler *handler)
{
HippoUStr utf(str);
long bytesTotal = (long) strlen(utf.c_str());
bool ret = writeAllToStream(stream, (void *)utf.c_str(), bytesTotal, handler);
return ret;
}
void ShowMessageInline(const MCONTACT hContact, const wchar_t *msg) {
wchar_t buff[1024];
mir_snwprintf(buff, L"%s%s", _A2W(LANG_INLINE_PREFIX), msg);
T2Utf utf(buff);
PROTORECVEVENT pre = {0};
pre.timestamp = time(0);
pre.szMessage = utf;
pre.flags = PREF_BYPASS_OTR;
ProtoChainRecvMsg(hContact, &pre);
}
void object::test<3>()
{
try
{
se << utf(L"select * from undefined_table");
fail( "exception expected" );
}
catch (sqlitepp::exception const&)
{
}
}
void transaction::rollback()
{
if ( do_rollback_ && s_ )
{
*s_ << utf("rollback");
}
if ( s_ )
{
s_->active_txn_ = nullptr;
}
do_rollback_ = false;
}
void object::test<4>()
{
try
{
se << utf(L"qaz");
fail( "exception expected");
}
catch (sqlitepp::exception const& ex)
{
ensure( "error code", ex.code() != 0 );
ensure( "what", ex.what() != 0 );
}
}
TupVideoProperties::TupVideoProperties(const TupExportWidget *widget) : TupExportWizardPage(tr("Set Animation Properties"))
{
setTag("PROPERTIES");
QLocale utf(QLocale::AnyLanguage, QLocale::AnyCountry);
isOk = false;
connect(widget, SIGNAL(saveVideoToServer()), this, SLOT(postIt()));
QWidget *container = new QWidget;
QVBoxLayout *layout = new QVBoxLayout(container);
QLabel *titleLabel = new QLabel(tr("Title"));
titleEdit = new QLineEdit(tr("My Video"));
titleEdit->setLocale(utf);
connect(titleEdit, SIGNAL(textChanged(const QString &)), this, SLOT(resetTitleColor(const QString &)));
titleLabel->setBuddy(titleEdit);
QLabel *topicsLabel = new QLabel(tr("Topics"));
topicsEdit = new QLineEdit(tr("#topic1 #topic2 #topic3"));
topicsEdit->setLocale(utf);
connect(topicsEdit, SIGNAL(textChanged(const QString &)), this, SLOT(resetTopicsColor(const QString &)));
topicsLabel->setBuddy(topicsEdit);
QLabel *descLabel = new QLabel(tr("Description"));
descText = new QTextEdit;
descText->setLocale(utf);
descText->setAcceptRichText(false);
descText->setFixedHeight(80);
descText->setText(tr("Just a little taste of my style :)"));
QHBoxLayout *exportLayout = new QHBoxLayout;
exportLayout->setAlignment(Qt::AlignHCenter);
QHBoxLayout *topLayout = new QHBoxLayout;
topLayout->addWidget(titleLabel);
topLayout->addWidget(titleEdit);
QHBoxLayout *middleLayout = new QHBoxLayout;
middleLayout->addWidget(topicsLabel);
middleLayout->addWidget(topicsEdit);
layout->addLayout(exportLayout);
layout->addLayout(topLayout);
layout->addLayout(middleLayout);
layout->addWidget(descLabel);
layout->addWidget(descText);
setWidget(container);
}
u32 sceCccDecodeUTF8(u32 dstAddrAddr)
{
auto dstp = PSPPointer<PSPCharPointer>::Create(dstAddrAddr);
if (!dstp.IsValid() || !dstp->IsValid()) {
ERROR_LOG(HLE, "sceCccDecodeUTF8(%08x): invalid pointer", dstAddrAddr);
// Should crash?
return 0;
}
DEBUG_LOG(HLE, "sceCccDecodeUTF8(%08x)", dstAddrAddr);
UTF8 utf(*dstp);
u32 result = utf.next();
*dstp += utf.byteIndex();
if (result == UTF8::INVALID)
return errorUTF8;
return result;
}
u32 sceCccDecodeUTF16(u32 dstAddrAddr)
{
auto dstp = PSPPointer<PSPWCharPointer>::Create(dstAddrAddr);
if (!dstp.IsValid() || !dstp->IsValid()) {
ERROR_LOG(HLE, "sceCccDecodeUTF16(%08x): invalid pointer", dstAddrAddr);
// Should crash?
return 0;
}
DEBUG_LOG(HLE, "sceCccDecodeUTF16(%08x)", dstAddrAddr);
// TODO: Does it do any detection of BOM?
UTF16LE utf(*dstp);
u32 result = utf.next();
*dstp += utf.byteIndex();
if (result == UTF16LE::INVALID)
return errorUTF16;
return result;
}
unsigned int Input::calculateBestYOffset(const std::string& s)
{
const osgText::FontResolution fr(static_cast<unsigned int>(_text->getCharacterHeight()),
static_cast<unsigned int>(_text->getCharacterHeight()));
osgText::String utf(s);
unsigned int descent = 0;
for(osgText::String::iterator i = utf.begin(); i != utf.end(); i++) {
osgText::Font* font = const_cast<osgText::Font*>(_text->getFont());
osgText::Font::Glyph* glyph = font->getGlyph(fr, *i);
unsigned int d = abs((int)glyph->getHorizontalBearing().y());
if(d > descent) descent = d;
}
return descent;
}
int main(int argc, char **argv) {
if (test_common_init(&argc, &argv) != 0)
return -1;
// Test case from RFC 3492 (7.1 - Simplified Chinese)
const char plain[] =
"\xE4\xBB\x96\xE4\xBB\xAC\xE4\xB8\xBA\xE4\xBB\x80\xE4\xB9\x88\xE4\xB8\x8D\xE8\xAF\xB4\xE4\xB8\xAD\xE6\x96\x87";
const char encoded[] = "xn--ihqwcrb4cv8a8dqg056pqjye";
nsCOMPtr<nsIIDNService> converter = do_GetService(NS_IDNSERVICE_CONTRACTID);
NS_ASSERTION(converter, "idnSDK not installed!");
if (converter) {
nsAutoCString buf;
nsresult rv = converter->ConvertUTF8toACE(NS_LITERAL_CSTRING(plain), buf);
NS_ASSERTION(NS_SUCCEEDED(rv), "error ConvertUTF8toACE");
NS_ASSERTION(buf.Equals(NS_LITERAL_CSTRING(encoded)),
"encode result incorrect");
printf("encoded = %s\n", buf.get());
buf.Truncate();
rv = converter->ConvertACEtoUTF8(NS_LITERAL_CSTRING(encoded), buf);
NS_ASSERTION(NS_SUCCEEDED(rv), "error ConvertACEtoUTF8");
NS_ASSERTION(buf.Equals(NS_LITERAL_CSTRING(plain)),
"decode result incorrect");
printf("decoded = ");
NS_ConvertUTF8toUTF16 utf(buf);
const char16_t *u = utf.get();
for (int i = 0; u[i]; i++) {
printf("U+%.4X ", u[i]);
}
printf("\n");
bool isAce;
rv = converter->IsACE(NS_LITERAL_CSTRING("www.xn--ihqwcrb4cv8a8dqg056pqjye.com"), &isAce);
NS_ASSERTION(NS_SUCCEEDED(rv), "error IsACE");
NS_ASSERTION(isAce, "IsACE incorrect result");
}
return 0;
}
