TEST(Reader, Parse_IStreamWrapper_StringStream) {
const char* json = "[1,2,3,4]";
std::stringstream ss(json);
IStreamWrapper is(ss);
Reader reader;
ParseArrayHandler<4> h;
reader.Parse(is, h);
EXPECT_FALSE(reader.HasParseError());
}
std::pair<SymbolID, std::vector<Ref>>
readRefs(Reader &Data, llvm::ArrayRef<llvm::StringRef> Strings) {
std::pair<SymbolID, std::vector<Ref>> Result;
Result.first = Data.consumeID();
Result.second.resize(Data.consumeVar());
for (auto &Ref : Result.second) {
Ref.Kind = static_cast<RefKind>(Data.consume8());
Ref.Location = readLocation(Data, Strings);
}
return Result;
}
std::map<int, int> Compression::calculate_frequency(Reader& reader) {
reader.set_begin();
std::map<int, int> frequency;
char ch;
while (reader.getchar(ch)) {
frequency[ch]++;
}
print(frequency);
return frequency;
}
IncludeGraphNode readIncludeGraphNode(Reader &Data,
llvm::ArrayRef<llvm::StringRef> Strings) {
IncludeGraphNode IGN;
IGN.IsTU = Data.consume8();
IGN.URI = Data.consumeString(Strings);
llvm::StringRef Digest = Data.consume(IGN.Digest.size());
std::copy(Digest.bytes_begin(), Digest.bytes_end(), IGN.Digest.begin());
IGN.DirectIncludes.resize(Data.consumeVar());
for (llvm::StringRef &Include : IGN.DirectIncludes)
Include = Data.consumeString(Strings);
return IGN;
}
// Too complicated to be inline
Result
ReadTagAndGetValue(Reader& input, /*out*/ uint8_t& tag, /*out*/ Input& value)
{
Result rv;
rv = input.Read(tag);
if (rv != Success) {
return rv;
}
if ((tag & 0x1F) == 0x1F) {
return Result::ERROR_BAD_DER; // high tag number form not allowed
}
uint16_t length;
// The short form of length is a single byte with the high order bit set
// to zero. The long form of length is one byte with the high order bit
// set, followed by N bytes, where N is encoded in the lowest 7 bits of
// the first byte.
uint8_t length1;
rv = input.Read(length1);
if (rv != Success) {
return rv;
}
if (!(length1 & 0x80)) {
length = length1;
} else if (length1 == 0x81) {
uint8_t length2;
rv = input.Read(length2);
if (rv != Success) {
return rv;
}
if (length2 < 128) {
// Not shortest possible encoding
return Result::ERROR_BAD_DER;
}
length = length2;
} else if (length1 == 0x82) {
rv = input.Read(length);
if (rv != Success) {
return rv;
}
if (length < 256) {
// Not shortest possible encoding
return Result::ERROR_BAD_DER;
}
} else {
// We don't support lengths larger than 2^16 - 1.
return Result::ERROR_BAD_DER;
}
return input.Skip(length, value);
}
int32 JampCellPerformance::Deserialize(std::string jsonSrc)
{
if (jsonSrc.length() == 0)
return 0;
Reader reader;
Value value;
reader.parse(jsonSrc, value, false);
return DeserializeFromValue(value);
}
TestBody( const char* filename )
: written_model_(),
read_model_()
{
SWEET_ASSERT( filename );
Writer writer;
writer.write( filename, "model", written_model_ );
read_model_.clear();
Reader reader;
reader.read( filename, "model", read_model_ );
}
Result
ExtractSignedCertificateTimestampListFromExtension(Input extnValue,
Input& sctList)
{
Reader decodedValue;
Result rv = der::ExpectTagAndGetValueAtEnd(extnValue, der::OCTET_STRING,
decodedValue);
if (rv != Success) {
return rv;
}
return decodedValue.SkipToEnd(sctList);
}
Instruction * DeserialInstruction(StringType strInst)
{
Reader reader;
Value jsonInst;
reader.parse(strInst, jsonInst);
Instruction * ip = new Instruction(
jsonInst["ClientID"].asInt(),
(InstructionType)(jsonInst["InstType"].asInt()),
jsonInst["InstructionID"].asInt()
);
return ip;
}
int main()
{
Reader rr;
int T = rr.next_u32();
rr.skip_line();
rr.skip_line();
bool first = true;
while (T--) {
nt = 0;
Neg(par);
while (true) {
rr.next_real_line(line, len);
if (strcmp("", line) == 0) break;
int team, prob, time;
char L;
sscanf(line, "%d%d%d %c", &team, &prob, &time, &L);
if (par[team] < 0) {
par[team] = nt++;
contest[par[team]] = Team(team);
}
int idx = par[team];
// penalty per problem is negative if it has been solved
if (contest[idx].pp[prob] < 0 ||
(L != 'C' && L != 'I')) continue;
if (L == 'C') {
++contest[idx].s;
contest[idx].p += contest[idx].pp[prob] + time;
contest[idx].pp[prob] = -1;
}
else
contest[idx].pp[prob] += 20;
}
sort(contest, contest + nt);
if (first) first = false;
else puts("");
for (int i = 0; i < nt; ++i)
printf("%d %d %d\n", contest[i].n, contest[i].s, contest[i].p);
}
return 0;
}
void IndexBuilder::writeSnapshots(Reader &reader, KZip &zip)
{
static const qint64 SNAPSHOT_INTERVAL_MS = 1000; // snapshot interval in milliseconds
static const int SNAPSHOT_MIN_ACTIONS = 200; // minimum number of actions between snapshots
paintcore::LayerStack image;
net::LayerListModel layermodel;
canvas::StateTracker statetracker(&image, &layermodel, 1);
MessageRecord msg;
int snapshotCounter = 0;
QElapsedTimer timer;
timer.start();
while(true) {
if(_abortflag.load())
return;
msg = reader.readNext();
if(msg.status == MessageRecord::END_OF_RECORDING)
break;
else if(msg.status == MessageRecord::INVALID)
continue;
protocol::MessagePtr m(msg.message);
if(m->isCommand()) {
statetracker.receiveCommand(m);
++snapshotCounter;
}
// Save a snapshot every SNAPSHOT_INTERVAL or at every marker. (But no more often than SNAPSHOT_MIN_ACTIONS)
// Note. We use the actual elapsed rendering time to decide when to snapshot. This means that (ideally),
// the time it takes to jump to a snapshot is at most SNAPSHOT_INTERVAL milliseconds (+ the time it takes to load the snapshot)
if(m_index.snapshots().isEmpty() || ((timer.hasExpired(SNAPSHOT_INTERVAL_MS) || m->type() == protocol::MSG_MARKER) && snapshotCounter>=SNAPSHOT_MIN_ACTIONS)) {
qint64 streampos = reader.filePosition();
emit progress(streampos);
canvas::StateSavepoint sp = statetracker.createSavepoint(-1);
QBuffer buf;
buf.open(QBuffer::ReadWrite);
{
QDataStream ds(&buf);
sp.toDatastream(ds);
}
int snapshotIdx = m_index.m_snapshots.size();
zip.writeFile(QString("snapshot-%1").arg(snapshotIdx), buf.data());
m_index.m_snapshots.append(SnapshotEntry(streampos, reader.currentIndex()));
snapshotCounter = 0;
timer.restart();
}
}
}
//--------------------------------------------------------------
bool JSONElement::openRemote(string filename) {
string result;
// TO DO -- put some CURL shit here
Reader reader;
if(!reader.parse( result, *this )) {
cout << "Unable to parse " << filename << endl;
return false;
}
return true;
}
int main(int argc, char *argv[]){
qInstallMessageHandler(myMessageOutput);
QCoreApplication a(argc, argv);
glb::mainThread = a.thread();
std::cout << std::endl << "Oi, mate!";
qRegisterMetaType<QAbstractSocket::SocketError>();
qRegisterMetaType<QAbstractSocket::SocketState>();
//set current working directory to executable path
//needed if started from within IDE
boost::filesystem::path curDir(QCoreApplication::applicationDirPath().toStdString());
boost::filesystem::current_path(curDir);
srand(time(NULL));
int alg = 0;
if (argc < 2){
std::cout << std::endl << "No algorithm specified -> using Central Mutual Exclusion algorithm";
}
else{
QString inputAlg = argv[1];
if (inputAlg == "RA"){
std::cout << std::endl << "Ricart Agrawala algorithm selected";
alg = 1;
}
else if (inputAlg == "CME"){
std::cout << std::endl << "Central Mutual Exclusion algorithm selected";
}
else{
std::cout << std::endl << "unknown algorithm specified -> using Central Mutual Exclusion algorithm";
}
}
if (alg == 1){
}
else{
//init the Server
Server* server = new Server();
server->init();
Reader* reader = new Reader(server->getClient());
reader->start();
}
return a.exec();
}
// BasicOCSPResponse ::= SEQUENCE {
// tbsResponseData ResponseData,
// signatureAlgorithm AlgorithmIdentifier,
// signature BIT STRING,
// certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL }
Result
BasicResponse(Reader& input, Context& context)
{
Reader tbsResponseData;
SignedDataWithSignature signedData;
Result rv = der::SignedData(input, tbsResponseData, signedData);
if (rv != Success) {
if (rv == Result::ERROR_BAD_SIGNATURE) {
return Result::ERROR_OCSP_BAD_SIGNATURE;
}
return rv;
}
// Parse certificates, if any
NonOwningDERArray certs;
if (!input.AtEnd()) {
// We ignore the lengths of the wrappers because we'll detect bad lengths
// during parsing--too short and we'll run out of input for parsing a cert,
// and too long and we'll have leftover data that won't parse as a cert.
// [0] wrapper
Reader wrapped;
rv = der::ExpectTagAndGetValueAtEnd(
input, der::CONTEXT_SPECIFIC | der::CONSTRUCTED | 0, wrapped);
if (rv != Success) {
return rv;
}
// SEQUENCE wrapper
Reader certsSequence;
rv = der::ExpectTagAndGetValueAtEnd(wrapped, der::SEQUENCE, certsSequence);
if (rv != Success) {
return rv;
}
// sequence of certificates
while (!certsSequence.AtEnd()) {
Input cert;
rv = der::ExpectTagAndGetTLV(certsSequence, der::SEQUENCE, cert);
if (rv != Success) {
return rv;
}
rv = certs.Append(cert);
if (rv != Success) {
return rv;
}
}
}
return ResponseData(tbsResponseData, context, signedData, certs);
}
TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativePull_DummyHandler)) {
for (size_t i = 0; i < kTrialCount; i++) {
StringStream s(json_);
BaseReaderHandler<> h;
Reader reader;
reader.IterativeParseInit();
while (!reader.IterativeParseComplete()) {
if (!reader.IterativeParseNext<kParseDefaultFlags>(s, h))
break;
}
EXPECT_FALSE(reader.HasParseError());
}
}
int main()
{
Reader rr;
while (true) {
rr.next_line(game);
if (game[0] == 'G') break;
printf("%d\n", score());
}
return 0;
}
void deserialize(Reader &is) {
clear();
is.read((char*)&num_buckets_, sizeof(num_buckets_));
index_ = new KMerDataIndex[num_buckets_];
for (size_t i = 0; i < num_buckets_; ++i)
index_[i].deserialize(is);
bucket_starts_.resize(num_buckets_ + 1);
is.read((char*)&bucket_starts_[0], (num_buckets_ + 1) * sizeof(bucket_starts_[0]));
count_size();
}
int main() {
UnixBuilder unixBuilder;
VmsBuilder vmsBuilder;
Reader reader;
// Reader: director
reader.setBuilder(&unixBuilder);
reader.construct(input, NUM_ENTRIES);
std::cout << unixBuilder.getResult()->getState() << std::endl;
reader.setBuilder(&vmsBuilder);
reader.construct(input, NUM_ENTRIES);
std::cout << vmsBuilder.getResult()->getState() << std::endl;
}
int32 PhunePreferenceBase64::Deserialize(std::string jsonSrc)
{
if (jsonSrc.length() == 0)
return 0;
Reader reader;
Value jsonValue;
reader.parse(jsonSrc, jsonValue, false);
return DeserializeFromValue(jsonValue);
}
int client(int nframes, std::string &name)
{
Reader reader;
reader.nframes=nframes;
bool forever=false;
if (nframes==-1)
forever=true;
else
reader.latencies.reserve(nframes);
std::string portName;
portName="/profiling/client/";
portName+=name;
portName+="/port:i";
reader.useCallback();
reader.open(portName.c_str());
portName="/profiling/client/";
portName+=name;
portName+="/port:o";
reader.outPort.open(portName.c_str());
while( (reader.count<nframes) || forever)
{
//give the CPU some time
Time::delay(0.5);
}
reader.close();
std::vector<Report>::iterator it=reader.latencies.begin();
FILE *of=fopen("timing.txt", "w");
while(it!=reader.latencies.end())
{
fprintf(of, "%u %lf\n", (*it).payload, (*it).dt);
it++;
}
fclose(of);
double averageLatency=reader.delay/reader.count;
double stdLatency=(1.0/(reader.count-1))*(reader.delaySq-reader.count*averageLatency*averageLatency);
stdLatency=sqrt(stdLatency);
fprintf(stderr, "Received: %d average latency %.3lf +/- %.5lf [ms]\n",
reader.count, averageLatency, stdLatency);
return 0;
}
void datahandle(struct user *puser)
{
Value root;
Reader reader;
int typecode;
string data = puser->data;
cout<<"in datahandle: "<<data<<endl;
if(reader.parse(data,root))
typecode = root["typecode"].asInt();
cout<<"typecode:"<<typecode<<endl;
if(typecode == 0)
{
cout<<"data is wrong"<<endl;
}
switch(typecode)
{
case 1: //regist
case 40: add_job(pool, regist_change, puser); break; //change information
case 20: add_job(pool, login, puser); break; //login
case 500: add_job(pool, privatemsg ,puser); break;
case 600: add_job(pool, tofocus,puser); break;
case 620: add_job(pool, getfocuslist ,puser); break;
case 640: add_job(pool, getfanslist ,puser); break;
case 1000: //get private qunlist
case 1100: add_job(pool, getqunlist, puser); break; //get public qunlist
case 1020: add_job(pool, deletequn ,puser); break;
case 1040: add_job(pool, quitqun, puser); break;
case 1060: add_job(pool, addqun, puser); break;
case 1061:
case 1062: add_job(pool, respaddqun, puser); break;
case 1120: add_job(pool, serqun ,puser); break;
case 1300: add_job(pool, createqun ,puser); break;
case 1200: add_job(pool, chat, puser); break;
case 1210: add_job(pool, getqunrecord, puser); break;
case 2000: add_job(pool, createhottie, puser); break;//create hot tie
case 2100: add_job(pool, getsavedhotielist, puser); break;
case 2020: add_job(pool, gethottielist, puser); break;
case 2080: add_job(pool, getonehottie, puser); break;
case 2040: add_job(pool, getprivatehottielist, puser); break;
case 2060: add_job(pool, savehottie, puser); break;
case 3000: add_job(pool, askpk, puser); break;
case 3001: add_job(pool, quitpk, puser); break;
case 3002: add_job(pool, quitgame, puser); break;
case 3003: add_job(pool, finishgame, puser); break;
default: break;
}
}
/**
* Retrieves the state of the simulator.
* @return The state of the simulator.
*/
const JsonClient::SIMULATORSTATE JsonClient::getSimulatorState() {
lock_guard<mutex> guardCurl(curlMutex);
// Set the URL
curl_easy_setopt(curl, CURLOPT_URL, (this->address + "json_output?state=getIt").c_str());
string recvHeader;
string recvBody;
// Send a GET request
curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
// Write no body
curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
// Send all received data to this function
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeStrCallback);
// We want the headers be written to string
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, &recvHeader);
// We want the body be written to this string
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &recvBody);
// Perform the request && check for errors
//cerr << "start curl_easy_perform in line " << __LINE__ << ", now " << curls_running << " are running.\n"; curls_running++;
if(curl_easy_perform(curl) != CURLE_OK) {
//cerr << "end curl_easy_perform in line " << __LINE__ << ", now " << curls_running << " are running.\n"; curls_running--;
return UNKNOWN;
}
//cerr << "end curl_easy_perform in line " << __LINE__ << ", now " << curls_running << " are running.\n"; curls_running--;
// Check headers if successful, we want:
// HTTP/1.0 200 Ok
string code = recvHeader.substr(9, 3);
if (code.compare("200") != 0) {
return UNKNOWN;
}
Reader reader;
Value value;
if (reader.parse(recvBody, value)) {
if (value["serverState"].compare("running") == 0)
return RUNNING;
else if (value["serverState"].compare("paused") == 0)
return PAUSED;
}
return UNKNOWN;
}
bool MultipartParser::parseFileContentDisposition(Reader &r) {
r.skipChars<Reader::CharGroup<chars::CharGroupId::WhiteSpace>, Reader::Chars<';'>>();
if (r.empty()) { return true; }
Reader name;
while (!r.empty()) {
if (r.is("name=")) {
r.offset(5);
if (r.is('"')) {
++ r;
name = r.readUntil<Reader::Chars<'"'>>();
} else {
name = r.readUntil<Reader::CharGroup<chars::CharGroupId::WhiteSpace>, Reader::Chars<';'>>();
}
}
r.skipUntil<Reader::Chars<';'>>();
r.skipChars<Reader::CharGroup<chars::CharGroupId::WhiteSpace>, Reader::Chars<';'>>();
}
if (!name.empty()) {
fileName = name.str();
return true;
}
return false;
}
void MsgBuf::read(Reader& in) {
while(!in.eof()) {
uint32_t type = in.get_binary<uint32_t>();
uint32_t time = in.get_binary<uint32_t>();
uint32_t len = in.get_binary<uint32_t>();
if(!in.eof()) {
std::string str_msg = in.get_string(len);
if(len == str_msg.size()) {
const TradeMsg msg(type, time, len, str_msg);
add(msg);
}
}
}
}
// For covering PutN() generic version
TEST(PrettyWriter, OStreamWrapper) {
StringStream s(kJson);
std::stringstream ss;
OStreamWrapper os(ss);
PrettyWriter<OStreamWrapper> writer(os);
Reader reader;
reader.Parse(s, writer);
std::string actual = ss.str();
EXPECT_STREQ(kPrettyJson, actual.c_str());
}
Gradient::Gradient(const Reader& reader) :
layer(LAYER_BACKGROUND0),
gradient_top(),
gradient_bottom()
{
layer = reader_get_layer (reader, /* default = */ LAYER_BACKGROUND0);
std::vector<float> bkgd_top_color, bkgd_bottom_color;
if(!reader.get("top_color", bkgd_top_color) ||
!reader.get("bottom_color", bkgd_bottom_color))
throw std::runtime_error("Must specify top_color and bottom_color in gradient");
gradient_top = Color(bkgd_top_color);
gradient_bottom = Color(bkgd_bottom_color);
}
int _tmain(int argc, _TCHAR* argv[])
{
//--- create pen ---//
da0lib::LaserPen* pLaserPen = CreateLaserPen();
da0lib::LASERPEN pen;
pen.penid = RGB(255, 255, 0);
pen.frequency = 12.34;
pen.pulsewidth = 234.345;
pen.speedmark = 333.223;
pLaserPen->update(pen.penid, &pen);
pLaserPen->save(L"test_xe4.pen");
//--- open pen ---//
pLaserPen->open(L"test_xe4.pen");
da0lib::LASERPEN* pPen = pLaserPen->query(RGB(255, 255, 0));
_tprintf(L"pen.penid : %d\n", pPen->penid);
_tprintf(L"pen.frequency : %.2f\n", pPen->frequency);
_tprintf(L"pen.pulsewidth : %.2f\n", pPen->pulsewidth);
_tprintf(L"pen.speedmark : %.2f\n\n", pPen->speedmark);
DestroyLaserPen(pLaserPen);
//--- create writer ---//
Writer* pWriter = da0lib::CreateWriter(L"test_xe4.da0");
pWriter->layerBegin(L"testlayer");
pWriter->shapeBegin();
pWriter->shapeLine(RGB(255,255,0), -1.1,2.2, 3.3, 4.4);
pWriter->shapeArc(RGB(255,255,0), 5,6,7,0,90);
pWriter->shapeRectangle(RGB(255,255,0), -7,8,9,-10);
DestroyWriter(pWriter);
//--- create reader ---//
Reader* pReader = da0lib::CreateReader(L"test_xe4.da0");
Readerable* pReaderable = new TMyReaderable();
pReader->load();
pReader->parse(pReaderable, NULL);
DestroyReader(pReader);
int t = getchar();
return 0;
}
TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativePullInsitu_DummyHandler)) {
for (size_t i = 0; i < kTrialCount; i++) {
memcpy(temp_, json_, length_ + 1);
InsituStringStream s(temp_);
BaseReaderHandler<> h;
Reader reader;
reader.IterativeParseInit();
while (!reader.IterativeParseComplete()) {
if (!reader.IterativeParseNext<kParseDefaultFlags|kParseInsituFlag>(s, h))
break;
}
EXPECT_FALSE(reader.HasParseError());
}
}
int main()
{
int T = rr.next_u32();
rr.skip_line();
int ncase = 0;
while (T--) {
read_text();
solve();
printf("Document %d: %d %d\n", ++ncase, p, q);
}
return 0;
}
int
CHelperUnit::_pay_res(NETInputPacket* pack)
{
int ret = 0;
int code = 0;
string json, result;
Reader r;
Value v;
unsigned long flow;
CClientUnit *c;
CDecoderUnit *d;
NETOutputPacket out;
CEncryptDecrypt ed;
log_debug("-------- CHelperUnit::_pay_res begin --------");
code = pack->ReadByte();
json = pack->ReadString();
log_debug("ErrCode: %d", code);
log_debug("JSON: %s", json.c_str());
if (r.parse(json, v)) {
flow = v["flow"].asUInt64();
result = v["result"].asString();
out.Begin(SERVER_CMD_REP);
out.WriteInt(0);
out.WriteString(result);
out.End();
} else { /* error handle */
out.Begin(SERVER_CMD_REP);
out.WriteInt(1);
out.WriteString("");
out.End();
log_debug("-------- CHelperUnit::_pay_res error --------");
ret = -1;
}
ed.EncryptBuffer(&out); /* 编码 */
c = _get_client_by_id(flow, &d);
if (c && c->get_state() != CONN_FATAL_ERROR) {
c->add_rsp_buf(out.packet_buf(), out.packet_size());
ret = c->send();
}
log_debug("-------- CHelperUnit::_pay_res end --------");
return ret;
}
