Data FileUtilsAndroid::getData(const std::string& filename, bool forString) { if (filename.empty()) { return Data::Null; } unsigned char* data = nullptr; ssize_t size = 0; string fullPath = fullPathForFilename(filename); // by lisyunn LOGD("*** 1fullPath = %s ***", fullPath.c_str()); if (fullPath[0] != '/') { string relativePath = string(); size_t position = fullPath.find("assets/"); if (0 == position) { // "assets/" is at the beginning of the path and we don't want it relativePath += fullPath.substr(strlen("assets/")); } else { relativePath += fullPath; } LOGD("relative path = %s", relativePath.c_str()); if (nullptr == FileUtilsAndroid::assetmanager) { LOGD("... FileUtilsAndroid::assetmanager is nullptr"); return Data::Null; } // by lisyunn start #if 0 // read asset data AAsset* asset = AAssetManager_open(FileUtilsAndroid::assetmanager, relativePath.c_str(), AASSET_MODE_UNKNOWN); if (nullptr == asset) { LOGD("asset is nullptr"); return Data::Null; } off_t fileSize = AAsset_getLength(asset); if (forString) { data = (unsigned char*) malloc(fileSize + 1); data[fileSize] = '\0'; } else { data = (unsigned char*) malloc(fileSize); } int bytesread = AAsset_read(asset, (void*)data, fileSize); size = bytesread; AAsset_close(asset); // using obb expansion for android (cocos2dx-3.x) #else string path = getApkPath(); LOGD("*** getApkPath = %s ***", path.c_str()); string datapath = "assets/" + relativePath; // zip fileから指定した画像を読み出して表示 data = FileUtils::getInstance()->getFileDataFromZip(path.c_str() ,datapath.c_str(),&size); #endif // by lisyunn end } else { do { // read rrom other path than user set it //CCLOG("GETTING FILE ABSOLUTE DATA: %s", filename); const char* mode = nullptr; if (forString) mode = "rt"; else mode = "rb"; FILE *fp = fopen(fullPath.c_str(), mode); CC_BREAK_IF(!fp); long fileSize; fseek(fp,0,SEEK_END); fileSize = ftell(fp); fseek(fp,0,SEEK_SET); if (forString) { data = (unsigned char*) malloc(fileSize + 1); data[fileSize] = '\0'; } else { data = (unsigned char*) malloc(fileSize); } fileSize = fread(data,sizeof(unsigned char), fileSize,fp); fclose(fp); size = fileSize; } while (0); } Data ret; if (data == nullptr || size == 0) { std::string msg = "Get data from file("; msg.append(filename).append(") failed!"); CCLOG("%s", msg.c_str()); } else { ret.fastSet(data, size); } return ret; }
int Ardb::SortCommand(Context& ctx, const Slice& key, SortOptions& options, DataArray& values) { values.clear(); KeyType keytype = KEY_END; GetType(ctx, key, keytype); switch (keytype) { case LIST_META: { ListRange(ctx, key, 0, -1); break; } case SET_META: { SetMembers(ctx, key); break; } case ZSET_META: { ZSetRange(ctx, key, 0, -1, false, false, OP_GET); if (NULL == options.by) { options.nosort = true; } break; } default: { return ERR_INVALID_TYPE; } } DataArray sortvals; if (ctx.reply.MemberSize() > 0) { for (uint32 i = 0; i < ctx.reply.MemberSize(); i++) { Data v; v.SetString(ctx.reply.MemberAt(i).str, true); sortvals.push_back(v); } } if (sortvals.empty()) { return 0; } if (options.with_limit) { if (options.limit_offset < 0) { options.limit_offset = 0; } if ((uint32) options.limit_offset > sortvals.size()) { values.clear(); return 0; } if (options.limit_count < 0) { options.limit_count = sortvals.size(); } } std::vector<SortValue> sortvec; if (!options.nosort) { if (NULL != options.by) { sortvec.reserve(sortvals.size()); } for (uint32 i = 0; i < sortvals.size(); i++) { if (NULL != options.by) { sortvec.push_back(SortValue(&sortvals[i])); if (GetValueByPattern(ctx, options.by, sortvals[i], sortvec[i].cmp) < 0) { DEBUG_LOG("Failed to get value by pattern:%s", options.by); sortvec[i].cmp.Clear(); continue; } } if (options.with_alpha) { if (NULL != options.by) { sortvec[i].cmp.ToString(); } else { sortvals[i].ToString(); } } } if (NULL != options.by) { if (!options.is_desc) { std::sort(sortvec.begin(), sortvec.end(), less_value<SortValue>); } else { std::sort(sortvec.begin(), sortvec.end(), greater_value<SortValue>); } } else { if (!options.is_desc) { std::sort(sortvals.begin(), sortvals.end(), less_value<Data>); } else { std::sort(sortvals.begin(), sortvals.end(), greater_value<Data>); } } } if (!options.with_limit) { options.limit_offset = 0; options.limit_count = sortvals.size(); } uint32 count = 0; for (uint32 i = options.limit_offset; i < sortvals.size() && count < (uint32) options.limit_count; i++, count++) { Data* patternObj = NULL; if (NULL != options.by) { patternObj = sortvec[i].value; } else { patternObj = &(sortvals[i]); } if (options.get_patterns.empty()) { values.push_back(*patternObj); } else { for (uint32 j = 0; j < options.get_patterns.size(); j++) { Data vo; if (GetValueByPattern(ctx, options.get_patterns[j], *patternObj, vo) < 0) { DEBUG_LOG("Failed to get value by pattern for:%s", options.get_patterns[j]); vo.Clear(); } values.push_back(vo); } } } uint32 step = options.get_patterns.empty() ? 1 : options.get_patterns.size(); switch (options.aggregate) { case AGGREGATE_SUM: case AGGREGATE_AVG: { DataArray result; result.resize(step); for (uint32 i = 0; i < result.size(); i++) { for (uint32 j = i; j < values.size(); j += step) { result[i].IncrBy(values[j]); } } if (options.aggregate == AGGREGATE_AVG) { size_t count = values.size() / step; for (uint32 i = 0; i < result.size(); i++) { result[i].SetDouble(result[i].NumberValue() / count); } } values.assign(result.begin(), result.end()); break; } case AGGREGATE_MAX: case AGGREGATE_MIN: { DataArray result; result.resize(step); for (uint32 i = 0; i < result.size(); i++) { for (uint32 j = i; j < values.size(); j += step) { if (result[i].IsNil()) { result[i] = values[j]; } else { if (options.aggregate == AGGREGATE_MIN) { if (values[j] < result[i]) { result[i] = values[j]; } } else { if (values[j] > result[i]) { result[i] = values[j]; } } } } } values.assign(result.begin(), result.end()); break; } case AGGREGATE_COUNT: { size_t size = values.size() / step; values.clear(); Data v; v.SetInt64(size); values.push_back(v); break; } default: { break; } } if (options.store_dst != NULL && !values.empty()) { DeleteKey(ctx, options.store_dst); ValueObject list_meta; list_meta.key.key = options.store_dst; list_meta.key.type = KEY_META; list_meta.key.db = ctx.currentDB; list_meta.type = LIST_META; list_meta.meta.SetEncoding(COLLECTION_ECODING_ZIPLIST); BatchWriteGuard guard(GetKeyValueEngine()); DataArray::iterator it = values.begin(); while (it != values.end()) { if (!it->IsNil()) { std::string tmp; it->GetDecodeString(tmp); ListInsert(ctx, list_meta, NULL, tmp, false, false); } it++; } SetKeyValue(ctx, list_meta); } return 0; }
Data Data::operator *(const Data &data) const { if(data.type == INT) { Data ret(Data::INT); ret.value.i = value.i * data.value.i; return ret; } if(value.i < 0) { throw QString("Runtime error: invalid multiplication of multiset " + this->toString() + " * " + data.toString() ); } if(data.type == MULTIUNIT) { Data ret(Data::MULTIUNIT); ret.value.multiUnit = value.i * data.value.multiUnit; return ret; } else if(data.type == MULTIBOOL) { Data ret(Data::MULTIBOOL); ret.value.multiBool.t = value.i * data.value.multiBool.t; ret.value.multiBool.f = value.i * data.value.multiBool.f; return ret; } else if(data.type == MULTIINT) { Data ret(Data::MULTIINT); QMapIterator<int, int>i(*data.value.multiInt); while(i.hasNext()) { i.next(); if(value.i) ret.value.multiInt->insert(i.key(), i.value() * value.i); } return ret; } Q_ASSERT(false); return Data(); }
CachePtr(const CachePtr & other) {ptr = other.ptr; if (ptr) ptr->copy();}
Data FileUtilsAndroid::getData(const std::string& filename, bool forString) { if (filename.empty()) { return Data::Null; } unsigned char* data = nullptr; ssize_t size = 0; string fullPath = fullPathForFilename(filename); cocosplay::updateAssets(fullPath); if (fullPath[0] != '/') { string relativePath = string(); size_t position = fullPath.find("assets/"); if (0 == position) { // "assets/" is at the beginning of the path and we don't want it relativePath += fullPath.substr(strlen("assets/")); } else { relativePath += fullPath; } CCLOGINFO("relative path = %s", relativePath.c_str()); if (nullptr == FileUtilsAndroid::assetmanager) { LOGD("... FileUtilsAndroid::assetmanager is nullptr"); return Data::Null; } // read asset data AAsset* asset = AAssetManager_open(FileUtilsAndroid::assetmanager, relativePath.c_str(), AASSET_MODE_UNKNOWN); if (nullptr == asset) { LOGD("asset is nullptr"); return Data::Null; } off_t fileSize = AAsset_getLength(asset); if (forString) { data = (unsigned char*) malloc(fileSize + 1); data[fileSize] = '\0'; } else { data = (unsigned char*) malloc(fileSize); } int bytesread = AAsset_read(asset, (void*)data, fileSize); size = bytesread; AAsset_close(asset); } else { do { // read rrom other path than user set it //CCLOG("GETTING FILE ABSOLUTE DATA: %s", filename); const char* mode = nullptr; if (forString) mode = "rt"; else mode = "rb"; FILE *fp = fopen(fullPath.c_str(), mode); CC_BREAK_IF(!fp); long fileSize; fseek(fp,0,SEEK_END); fileSize = ftell(fp); fseek(fp,0,SEEK_SET); if (forString) { data = (unsigned char*) malloc(fileSize + 1); data[fileSize] = '\0'; } else { data = (unsigned char*) malloc(fileSize); } fileSize = fread(data,sizeof(unsigned char), fileSize,fp); fclose(fp); size = fileSize; } while (0); } Data ret; if (data == nullptr || size == 0) { std::string msg = "Get data from file("; msg.append(filename).append(") failed!"); CCLOG("%s", msg.c_str()); } else { ret.fastSet(data, size); cocosplay::notifyFileLoaded(fullPath); } return ret; }
Data Server::listen() { Data d; // read the key from the incoming data try { int key = -1; boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&key), sizeof(int))); switch( key ) { case 0: // open image { // send back an image id int image_id = 1; boost::asio::write(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&image_id), sizeof(int))); // get width & height int width, height, rArea, version; float currentFrame; boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&width), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&height), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&rArea), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&version), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(¤tFrame), sizeof(int))); // create data object d.mType = key; d.mWidth = width; d.mHeight = height; d.mRArea = rArea; d.mVersion = version; d.mCurrentFrame = currentFrame; break; } case 1: // image data { d.mType = key; // receive image id int image_id; boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&image_id), sizeof(int)) ); // get data info boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mX), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mY), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mWidth), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mHeight), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mRArea), sizeof(long long))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mVersion), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mCurrentFrame), sizeof(float))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mSpp), sizeof(int))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mRam), sizeof(long long))); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mTime), sizeof(int))); // get aov name's size size_t aov_size=0; boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&aov_size), sizeof(size_t))); // get aov name d.mAovName = new char[aov_size]; boost::asio::read(mSocket, boost::asio::buffer(d.mAovName, aov_size)); // get pixels int num_samples = d.width() * d.height() * d.spp(); d.mPixelStore.resize(num_samples); boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&d.mPixelStore[0]), sizeof(float)*num_samples)) ; break; } case 2: // close image { int image_id; d.mType = key; boost::asio::read(mSocket, boost::asio::buffer(reinterpret_cast<char*>(&image_id), sizeof(int))); mSocket.close(); break; } case 9: // quit { d.mType = 9; //debug Closing socket std::cout << "Socket closed" << std::endl; mSocket.close(); // This fixes all nuke destructor issues on windows mAcceptor.close(); break; } } } catch( ... ) { mSocket.close(); throw std::runtime_error("Could not read from socket!"); } return d; }
// main entry point, go ahead, have fun! int main(void) { // hold the power button for 3 seconds or shutdown //_delay_ms(STARTUP_DELAY); // keep power pin High unless we want to shutdown powerControl = 1; // disable JTAG so we can use PF4,PF5,PF6,PF7 for ADC and GPIO MCUCSR |=(1<<JTD);MCUCSR |=(1<<JTD); // two times!! // init time RTC time.init(callback_timeSecond, callback_timeMinute); time.startInterval(); // microcontroller features adc.init(); // needed by gp2y10 and more spi_init(); // needed by ILI9341 i2c_init(); // needed by bmp180 and mics-vz-89t uart1.init(1, 9600, 1); // needed by esp8266 . Interrupts are hard on parsing, polling would be easier but blocking uart0.init(0, 9600, 1); // CONFIGURE INTERRUPT INT4 to count pulses from Geiger Counter EICRB |= (1<<ISC00) | (1<<ISC01); // Configure INT4 to trigger on RISING EDGE EIMSK |= (1<<INT4); // Configure INT4 to fire interrupts // CREATE Timer T1 PWM to drive inverter for regulated Geiger tube voltage inverter.initPWM(); // init display lcd.init(); lcd.setRotation(ILI9341::ROT0); //lcd.drawClear(BLACK); backlight(true); // init sensors bmp180.init(); dust.init(&dustFlash, &adc, PF1); beep(); // start UI // enter main menu // ## touchscreen calibration code /*while (1) { uint16_t x = 0, y = 0, z = 0; if (touch.read(&x, &y , &z)) { lcd.drawPixel(x,y, 2, RED); } lcd.drawStringF(0,0,2,WHITE, BLACK, "%4u %4u %4u", touch.readRawX(), touch.readRawY(), touch.readRawPressure()); }*/ // draw GUI first page with self check if (!gui.drawPage(PAGE_INIT)) shutdown(); _delay_ms(1000); gui.drawPage(PAGE_MAIN); // ## main code loop while (1) { // ## beep if (cmdBeep && !cmdAlarm && !isMuted) { beep(); cmdBeep = false; } // ## read sensors // read inverter voltage, via 10M/47K resistive divider, connected to pin ADC2 data.geiger_voltage = readTubeVoltage(); inverter.adjustDutyCycle(data.geiger_voltage); // do nothing on failure, we can't reset // read battery data.battery_voltage = readBatVoltage(); // turn backlight off when timeout is reached if (secTimeout > BACKLIGHT_TIMEOUT) { backlight(false); secTimeout = 0; } // ## draw titlebar and refresh data display if (cmdRefreshText) { // sensor BMP180 bmp180.readAll(&data.bmp180_temp, &data.bmp180_pressure, &data.bmp180_altitude); dust.readDust(&data.gp2y10_dust); // sensor MICS-VZ-89T uint8_t reactivity = 0; // repeat until successful read with timeout? //int timeout = 10; //while (!vz89.read(&data.vz89_co2, &reactivity, &data.vz89_voc) && timeout) { _delay_ms(1500); timeout--; } vz89.read(&data.vz89_co2, &reactivity, &data.vz89_voc); // geiger readings //float dose = aux_CPM2uSVh((uint8_t)DEV_RAD_DETECTOR, geigerCPM); data.geiger_cpm = geigerCPM; data.time_hour = time.getHour(); data.time_minute = time.getMin(); data.time_second = time.getSec(); data.setLimits(); // must be changed to proper OOP set/get for all fields gui.updateValues(); // ## alarm condition if (geigerCPM >= GEIGER_CPM_ALARM) { // threshold to sound alarm reached cmdAlarm = ALARM_RADIATION; } else if (cmdAlarm) { // alarm should be turned off cmdAlarm = 0; speaker = 0; } cmdRefreshText = false; } // ## every minute we can dispatch data over serial or over WLAN to uradmonitor if (cmdSend) { char tmp[200]; sprintf(tmp,"{\"data\":{ \"id\":\"%08lX\"," "\"type\":\"%X\",\"detector\":\"%s\"," "\"cpm\":%lu,\"temperature\":%.2f,\"uptime\": %lu," "\"pressure\":%lu,\"dust\":%.2f,\"co2\":%.2f,\"voc\":%.2f," "\"battery\":%.2f,\"tube\":%u}}", deviceID, DEV_MODEL, aux_detectorName(DEV_RAD_DETECTOR), geigerCPM, data.bmp180_temp, time.getTotalSec(), data.bmp180_pressure, data.gp2y10_dust,data.vz89_co2, data.vz89_voc, data.battery_voltage, data.geiger_voltage); data.serial_sent += strlen(tmp); uart0.send(tmp); // internet code here sprintf(tmp,"id=%08lX&ts=%ld&inv=%d&ind=%d&s1t=%2.2f&cpm=%ld&voc=%.2f&co2=%.2f", deviceID, time.getTotalSec(), data.geiger_voltage, data.geiger_duty, data.bmp180_temp, geigerCPM, data.vz89_voc, data.vz89_co2); wifi.sendData(tmp); cmdSend = false; } // ## act on the gui elements // read a new touch event only if we are done with previous: useful for handling confirmation "modal" "dialogs" if (uiResult == 0) { uiResult = gui.readTouchEvent(); // reset backlight timeout on valid touch if (uiResult > 0) { secTimeout = 0; backlight(true); // if screen is pressed while alarm is on, stop alarm if (cmdAlarm) { cmdAlarm = false; speaker = 0; } } } // handle special cases: click on wlan AP buttons if (uiResult >= ID_BUTTON_WLAN_START && uiResult < ID_BUTTON_WLAN_STOP) { uint8_t ap_index = uiResult - ID_BUTTON_WLAN_START; // connect and return to main screen wifi.connectWiFi(data.freeAPList[ap_index], ""); uiResult = 0; gui.drawPage(PAGE_MAIN); } // handle regular buttons switch (uiResult) { case ID_BUTTON_SHUTDOWN: { uint16_t result = gui.showYesNoPopup("Are you sure?"); if (result == ID_YES) shutdown(); else if (result == ID_NO) { uiResult = 0; gui.drawPage(PAGE_MAIN); } } break; case ID_BUTTON_MEASURE: { uiResult = 0; gui.drawPage(PAGE_MEASURE); } break; case ID_BUTTON_MONITOR: { uiResult = 0; gui.drawPage(PAGE_MONITOR); } break; case ID_BUTTON_SETTINGS: { uiResult = 0; gui.drawPage(PAGE_SETTINGS); } break; case ID_BUTTON_BACK: { uiResult = 0; gui.drawPage(PAGE_MAIN); } break; case ID_BUTTON_MUTE: { isMuted = !isMuted; if (!isMuted) beep(); // test beep that sound is on uiResult = 0; } break; case ID_BUTTON_CALIBRATE: { uiResult = 0; gui.drawPage(PAGE_CALIBRATE); } break; case ID_BUTTON_WLAN: { // request list of WLAN APs data.freeAPCount = 0; //wifi.setMode(); wifi.listAP(); uiResult = 0; gui.drawPage(PAGE_WLAN); } break; // other commands that don't require a popup so we consume asap default: uiResult = 0; } //uint16_t x, y,z; //gui.getLastTouch(&x, &y, &z); //lcd.drawStringF(0,288, 2, RED, BLACK,"%u %d,%d ", uiResult, x,y); } }
void VarSelectorFind::getVariables(const Data& iData, int iInit, float iOffset, const Location& iLocation, std::vector<std::string>& iVariables) const { Input* inputF = iData.getInput(); Input* inputO = iData.getObsInput(); std::vector<std::string> variables; inputF->getVariables(variables); int locationId = iLocation.getId(); // Members std::vector<Member> members; inputF->getMembers(members); std::vector<std::string> varList; std::vector<std::string> varRemaining = variables; int numDays = (int) Global::getTimeDiff(mEndDate, 0, 0, mStartDate, 0, 0)/24; std::vector<float> obsTarget; obsTarget.resize(numDays); // Load the target observations for(int d = 0; d < numDays; d++) { int currDate = Global::getDate(mStartDate, 24*d); obsTarget[d] = inputO->getValue(currDate, iInit, iOffset, iLocation.getId(), 0, mVariable); } std::map<std::string, std::vector<float> > forecasts; std::vector<std::pair<std::string, float> > corrs; SelectorAnalog selector(makeOptionsObs(mVariable), iData); Parameters par; selector.getDefaultParameters(par); for(int v = 0; v < (int) variables.size(); v++) { std::string currVar = variables[v]; // Load the observations /* std::vector<float> obs; obs.resize(numDays); for(int d = 0; d < numDays; d++) { int currDate = Global::getDate(mStartDate, 24*d); obs[d] = inputO->getValue(currDate, iInit, iOffset, iLocation.getId(), 0, variables[v]); } */ double startTime = Global::clock(); // Load forecasts forecasts[currVar].resize(numDays-mTrainingDays); for(int d = mTrainingDays; d < numDays; d++) { int currDate = Global::getDate(mStartDate, 24*d); std::vector<float> values; inputF->getValues(currDate, iInit, iOffset, iLocation.getId(), currVar, values); forecasts[currVar][d-mTrainingDays] = Global::mean(values); } // For each day, find the analog that would have been the best std::vector<float> forecastsAtBest; forecastsAtBest.resize(numDays-mTrainingDays); for(int d = mTrainingDays; d < numDays; d++) { int currDate = Global::getDate(mStartDate, 24*d); //Global::logger->setDateInfo(currDate, d-mTrainingDays+1, numDays-mTrainingDays); std::vector<Field> slices; selector.select(currDate, iInit, iOffset, iLocation, mVariable, par, slices); // Get the forecasts at these times std::vector<float> temp; for(int i = 0; i < (int) slices.size(); i++) { // Since the observation dataset is used, past dates may be outside the range // TODO: This would be a problem since the selector only picks the n best analogs // TODO: Hard coded 10 if(temp.size() < 10) { if(slices[i].getDate() >= mStartDate && slices[i].getDate() <= mEndDate) { float value = inputF->getValue(slices[i].getDate(), slices[i].getInit(), slices[i].getOffset(), iLocation.getId(), slices[i].getMember().getId(), variables[v]); temp.push_back(value); //if(variables[v] == "CloudCover") // std::cout << "DATES: " << slices[i].getDate() << " " << value << std::endl; } } } float fcst = Global::mean(temp); // Forecasts at the best obs forecastsAtBest[d-mTrainingDays] = fcst; } // Compute the score float corr = Global::corr(forecasts[currVar], forecastsAtBest); if(Global::isValid(corr)) { float score = -corr; std::pair<std::string, float> p(variables[v], score); corrs.push_back(p); writeScore(variables[v], corr); } double endTime = Global::clock(); //std::cout << "Time = " << endTime - startTime << std::endl; } // Sort std::sort(corrs.begin(), corrs.end(), Global::sort_pair_second<std::string, float>()); assert(iVariables.size() == 0); // Check how many to add std::vector<std::string> currVars; std::vector<int> currVarsI; std::vector<std::string> bestVars; float bestScore = Global::INF; for(int v = 0; v < mMaxVars; v++) { if(v < corrs.size()) { std::string currVar = corrs[v].first; // Check that current variable isn't correlated to any added variables float varCorr = 0; for(int vv = 0; vv < currVars.size(); vv++) { varCorr = Global::corr(forecasts[currVar], forecasts[currVars[vv]]); std::cout << " varCorr[" << currVar << "," << currVars[vv] << "] = " << varCorr << std::endl; } if(!Global::isValid(varCorr) || fabs(varCorr) < mMaxVarCrossCorrelation) { currVars.push_back(currVar); currVarsI.push_back(v); float score = VarSelector::run(iData, iInit, iOffset, iLocation, currVars, *mDetMetric); std::cout << "Scores:"; for(int vv = 0; vv < currVars.size(); vv++) { std::cout << " " << currVars[vv]; } std::cout << " " << score << std::endl; if(score < bestScore) { bestScore = score; bestVars = currVars; } } } } iVariables = bestVars; }
void StateBox::parseFile(string filename){ ifstream file(filename.c_str()); if(!file){ cerr << "fichier inexistant" << endl; } string s; //Titre getline (file,s); //cout << s << endl; //saut de ligne getline (file,s); //cout << s << endl; //Sample size: getline (file,s); //cout << s << endl; int sampleSize; file >> sampleSize; //cout << sampleSize << endl; //saut de ligne getline (file,s); //cout << s << endl; double coord; int nbData; Point p(4); vector<Data*> vectData; Data* d; while(s.compare(0,5,"Order") != 0){ file >> s; //cout << s << endl; //getline (file,s); if(s.compare(0,9,"NewBranch") == 0){ file >> nbData; //cout << "nbData : " << nbData << endl; d = new Data(); vectData.push_back(d); for(int i = 0; i<nbData; i++){ //x1 file >> coord; //cout << coord << endl; p[0] = coord; //y1 file >> coord; //cout << coord << endl; p[1] = coord; //x2 file >> coord; //cout << coord << endl; p[2] = coord; //y2 file >> coord; //cout << coord << endl; p[3] = coord; getline (file,s); //cout << s << endl; d->addData(p); } d->setMean(Tools::averageMulDimNorm(*d)); d->setVar(Tools::varianceMulDimNorm(*d,d->getMean())); for(int i = 0; i<sampleSize; i++){ d->addSample(Tools::generateMulDim(d->getMean(),d->getVar())); } } }
int Ardb::LSet(Context& ctx, RedisCommandFrame& cmd) { int64 index; if (!GetInt64Value(ctx, cmd.GetArguments()[1], index)) { fill_error_reply(ctx.reply, "value is not an integer or out of range"); return 0; } ValueObject meta; int err = GetMetaValue(ctx, cmd.GetArguments()[0], LIST_META, meta); CHECK_ARDB_RETURN_VALUE(ctx.reply, err); if (0 != err) { fill_error_reply(ctx.reply, "no such key"); return 0; } if (meta.meta.Encoding() == COLLECTION_ENCODING_ZIPLIST) { Data* entry = GetZipEntry(meta.meta.ziplist, index); if (NULL == entry) { fill_error_reply(ctx.reply, "index out of range"); return 0; } else { entry->SetString(cmd.GetArguments()[2], true); SetKeyValue(ctx, meta); fill_status_reply(ctx.reply, "OK"); return 0; } } else { if (index >= meta.meta.Length() || (-index) > meta.meta.Length()) { fill_error_reply(ctx.reply, "index out of range"); return 0; } if (meta.meta.IsSequentialList()) { ValueObject list_element; list_element.key.db = meta.key.db; list_element.key.key = meta.key.key; list_element.key.type = LIST_ELEMENT; list_element.key.score = meta.meta.min_index; if (index >= 0) { list_element.key.score.IncrBy(index); } else { list_element.key.score.IncrBy(index + meta.meta.Length()); } if (0 == GetKeyValue(ctx, list_element.key, &list_element)) { list_element.element.SetString(cmd.GetArguments()[2], true); SetKeyValue(ctx, list_element); fill_status_reply(ctx.reply, "OK"); return 0; } } else { ListIterator iter; ListIter(ctx, meta, iter, index < 0); int64 cursor = index >= 0 ? 0 : -1; while (iter.Valid()) { if (cursor == index) { ValueObject v; v.key.db = meta.key.db; v.key.key = meta.key.key; v.key.type = LIST_ELEMENT; v.key.score = *(iter.Score()); v.type = LIST_ELEMENT; v.element.SetString(cmd.GetArguments()[2], true); SetKeyValue(ctx, v); fill_status_reply(ctx.reply, "OK"); return 0; } if (cursor >= 0) { cursor++; } else { cursor--; } if (index < 0) { iter.Prev(); } else { iter.Next(); } } } fill_error_reply(ctx.reply, "index out of range"); } return 0; }
int Task::svc (void) { this->barrier_.wait (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Task 0x%x starts in thread %d\n", (void *) this, ACE_Thread::self ())); ACE_Message_Block *message; for (;;) { if (this->getq (message) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "getq"), -1); if (message->msg_type () == ACE_Message_Block::MB_HANGUP) { this->putq (message); break; } const char *cp = message->rd_ptr (); // Don't forget to skip the NULL we inserted message->rd_ptr (ACE_OS::strlen (cp) + 1); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Block 0x%x contains (%s)\n", (void *) message, cp)); /* Create a Data object into which we can extract the message block contents. */ Data data; /* Use the rd_ptr() to access the message block data. Note that we've already moved it past the text string in the block. */ ACE_OS::memmove ((char *) &data, message->rd_ptr (), sizeof (data)); message->rd_ptr (sizeof (data)); // Move the rd_ptr() beyond the data. /* Invoke a couple of method calls on the object we constructed. */ data.who_am_i (); data.what_am_i (); /* An alternate approach: Data * data; data = (Data *)message->rd_ptr(); data->who_am_i(); data->what_am_i(); message->rd_ptr(sizeof(Data)); Even though this cuts down on the number of copies & constructions, I'm not real fond of it. You can get into trouble in a hurry by treating memory blocks as multiple data types... */ ACE_OS::sleep (ACE_Time_Value (0, 5000)); message->release (); } return 0; }
int Ardb::LRem(Context& ctx, RedisCommandFrame& cmd) { int64 count; if (!GetInt64Value(ctx, cmd.GetArguments()[1], count)) { return 0; } int64 toremove = std::abs(count); ValueObject meta; int err = GetMetaValue(ctx, cmd.GetArguments()[0], LIST_META, meta); CHECK_ARDB_RETURN_VALUE(ctx.reply, err); if (0 != err) { fill_int_reply(ctx.reply, 0); return 0; } Data element; element.SetString(cmd.GetArguments()[2], true); KeyLockerGuard lock(m_key_lock, ctx.currentDB, cmd.GetArguments()[0]); if (meta.meta.Encoding() == COLLECTION_ENCODING_ZIPLIST) { uint32 oldlen = meta.meta.ziplist.size(); int64 removed = 0; DataArray newzip; if (count >= 0) { for (uint32 i = 0; i < oldlen; i++) { if (meta.meta.ziplist[i] == element) { if (toremove == 0 || removed < toremove) { removed++; continue; } } newzip.push_back(meta.meta.ziplist[i]); } } else { for (uint32 i = 0; i < oldlen; i++) { if (meta.meta.ziplist[oldlen - 1 - i] == element) { if (toremove == 0 || removed < toremove) { removed++; continue; } } newzip.push_front(meta.meta.ziplist[i]); } } if (removed > 0) { meta.meta.ziplist = newzip; SetKeyValue(ctx, meta); } fill_int_reply(ctx.reply, removed); return 0; } BatchWriteGuard guard(GetKeyValueEngine()); ListIterator iter; ListIter(ctx, meta, iter, count < 0); int64 remove = 0; while (iter.Valid()) { if (iter.Element()->Compare(element) == 0) { meta.meta.len--; meta.meta.SetFlag(COLLECTION_FLAG_NORMAL); KeyObject k; k.db = meta.key.db; k.key = meta.key.key; k.type = LIST_ELEMENT; k.score = *(iter.Score()); DelRaw(ctx, iter.CurrentRawKey()); //DelKeyValue(ctx, k); remove++; if (remove == toremove) { break; } } if (count < 0) { iter.Prev(); } else { iter.Next(); } } if (remove > 0) { SetKeyValue(ctx, meta); } fill_int_reply(ctx.reply, remove); return 0; }
int Ardb::ListInsert(Context& ctx, ValueObject& meta, const std::string* match, const std::string& value, bool head, bool abort_nonexist) { if (WakeBlockList(ctx, meta.key.key, value)) { fill_int_reply(ctx.reply, 1); return 0; } if (NULL != match) { if (meta.meta.Encoding() == COLLECTION_ENCODING_ZIPLIST) { Data element; element.SetString(value, true); DataArray::iterator zit = meta.meta.ziplist.begin(); while (zit != meta.meta.ziplist.end()) { std::string tmp; zit->GetDecodeString(tmp); if (tmp == *match) { break; } zit++; } if (zit == meta.meta.ziplist.end()) { fill_int_reply(ctx.reply, 0); return 0; } if (head) { meta.meta.ziplist.insert(zit, element); } else { zit++; if (zit != meta.meta.ziplist.end()) { meta.meta.ziplist.insert(zit, element); } else { meta.meta.ziplist.push_back(element); } } if (meta.meta.Length() > 1 && (meta.meta.Length() >= m_cfg.list_max_ziplist_entries || element.StringLength() >= m_cfg.list_max_ziplist_value)) { //convert to non ziplist ZipListConvert(ctx, meta); } } else { ListIterator iter; ListIter(ctx, meta, iter, false); std::string tmp; Data prev, next; Data current; bool matched = false; while (iter.Valid()) { if (iter.Element()->GetDecodeString(tmp) == (*match)) { current = *(iter.Score()); matched = true; if (head) { break; } } if (head) { prev = *(iter.Score()); iter.Next(); } else { if (matched) { next = *(iter.Score()); break; } } iter.Next(); } if (!matched) { fill_int_reply(ctx.reply, 0); return 0; } Data score; if (head) { if (prev.IsNil()) { score = current.IncrBy(-1); } else { score.SetDouble((prev.NumberValue() + current.NumberValue()) / 2); meta.meta.SetFlag(COLLECTION_FLAG_NORMAL); } } else { if (next.IsNil()) { score = current.IncrBy(1); } else { score.SetDouble((next.NumberValue() + current.NumberValue()) / 2); meta.meta.SetFlag(COLLECTION_FLAG_NORMAL); } } meta.meta.len++; ValueObject v; v.type = LIST_ELEMENT; v.element.SetString(value, true); v.key.db = meta.key.db; v.key.key = meta.key.key; v.key.type = LIST_ELEMENT; v.key.score = score; SetKeyValue(ctx, v); } fill_int_reply(ctx.reply, meta.meta.Length()); return 0; } else { if (meta.meta.Encoding() == COLLECTION_ENCODING_ZIPLIST) { Data element; element.SetString(value, true); if (head) { meta.meta.ziplist.push_front(element); } else { meta.meta.ziplist.push_back(element); } if (meta.meta.Length() >= m_cfg.list_max_ziplist_entries || element.StringLength() >= m_cfg.list_max_ziplist_value) { //convert to non ziplist ZipListConvert(ctx, meta); } } else { meta.meta.len++; ValueObject v; v.type = LIST_ELEMENT; v.element.SetString(value, true); v.key.db = meta.key.db; v.key.key = meta.key.key; v.key.type = LIST_ELEMENT; if (head) { v.key.score = meta.meta.min_index.IncrBy(-1); } else { v.key.score = meta.meta.max_index.IncrBy(1); } SetKeyValue(ctx, v); } fill_int_reply(ctx.reply, meta.meta.Length()); return 0; } }
bool AppDelegate::applicationDidFinishLaunching() { // set default FPS Director::getInstance()->setAnimationInterval(1.0f / 60.0f); // register lua module auto engine = LuaEngine::getInstance(); ScriptEngineManager::getInstance()->setScriptEngine(engine); lua_State* L = engine->getLuaStack()->getLuaState(); lua_module_register(L); LuaRegister::openLibs(L); LuaUtil::openLibs(L); LuaNetwork::openLibs(L); luaopen_bit(L); luaopen_cjson(L); luaopen_md5_core(L); luaopen_lua_timer(L); //初始化lua加载函数 TDLuaMgr::instance(); register_all_packages(); LuaStack* stack = engine->getLuaStack(); stack->setXXTEAKeyAndSign("2dxLua", strlen("2dxLua"), "XXTEA", strlen("XXTEA")); #ifdef WIN32 std::string result = ""; WCHAR buf[1000 + 1]; int i = 1000; GetCurrentDirectory(1000, buf); //得到当前工作路径 cocos2d::StringUtils::UTF16ToUTF8((char16_t*)buf, result); result = result + "/../../"; cocos2d::log("add path is %s", result.c_str()); FileUtils::getInstance()->addSearchPath(result); FileUtils::getInstance()->addSearchPath(result + "/src"); FileUtils::getInstance()->addSearchPath(result + "/res"); for (auto path : cocos2d::FileUtils::getInstance()->getSearchPaths()) { cocos2d::log("search paths is %s", path.c_str()); } #endif { Data data = FileUtils::getInstance()->getDataFromFile("src/config/GlobalConfig.conf"); ConfigMgr::instance()->initGlobalConfig((const char*)data.getBytes(), data.getSize()); } // 设置脚本宏 LuaMgrIns->registerLuaGlobalVariable("SERVER_TYPE", "client"); Json::Value macro = GlobalConfig.get("lua_macros", Json::objectValue); for (auto mr : macro.getMemberNames()) { LuaMgrIns->registerLuaGlobalVariable(mr.c_str(), macro[mr.c_str()].asCString()); } { Data data = FileUtils::getInstance()->getDataFromFile("src/config/protocol.txt"); NetConfig::instance()->updateMessage((const char*)data.getBytes(), data.getSize()); } //CommandLine::instance()->CreateCmdLine(); Director::getInstance()->getScheduler()->schedule(std::bind(&AppDelegate::onUpdate, this, 0.1f), (void *)this, 0.1f, false, "onUpdate"); //register custom function //LuaStack* stack = engine->getLuaStack(); //register_custom_function(stack->getLuaState()); #if (COCOS2D_DEBUG > 0) && (CC_CODE_IDE_DEBUG_SUPPORT > 0) // NOTE:Please don't remove this call if you want to debug with Cocos Code IDE auto runtimeEngine = RuntimeEngine::getInstance(); runtimeEngine->addRuntime(RuntimeLuaImpl::create(), kRuntimeEngineLua); runtimeEngine->start(); #else if (engine->executeScriptFile("src/main.lua")) { return false; } #endif return true; }
leveldb::Slice slice(const Data& data) { return leveldb::Slice( reinterpret_cast<const char*>(data.data()), data.size()); }
void Wind::Event::clear() { Data* data = static_cast<Data*>(this->pQuantData); if (data != NULL) data->clear(); delete data; this->pQuantData = NULL; }
uint32_t recreate_height(const Data& raw_data) { const uint8_t* start = reinterpret_cast<const uint8_t*>(raw_data.data()); return from_little_endian<uint32_t>(start); }
void jeuEssai2() { Client* c1 = new Client("Client 1"); Client* c2 = new Client("Client 2"); Client* c3 = new Client("Client 3"); Client* c4 = new Client("Client 4"); Produit* p1 = new Produit("Produit 1"); Produit* p2 = new Produit("Produit 2"); Produit* p3 = new Produit("Produit 3"); Produit* p4 = new Produit("Produit 4"); Produit* p5 = new Produit("Produit 5"); Commande* co1 = new Commande(p1, 250); Commande* co2 = new Commande(p2, 250); Commande* co3 = new Commande(p3, 240); Commande* co4 = new Commande(p4, 300); Commande* co5 = new Commande(p5, 340); c1->addCommande(co1); c2->addCommande(co2); c3->addCommande(co3); c4->addCommande(co4); c4->addCommande(co5); c1->setKStockage(calculCout(1)); c2->setKStockage(calculCout(2)); c3->setKStockage(calculCout(3)); c4->setKStockage(calculCout(4)); std::cout << "Affichage des clients:" << endl; //std::cout << c1 << c2 << c3 << c4 << c5; Data* d = new Data(); Solution s(d); d->ajouterClient(c1); d->ajouterClient(c2); d->ajouterClient(c3); d->ajouterClient(c4); d->distanceClient(c1, 100); d->distanceClient(c2, 100); d->distanceClient(c3, 100); d->distanceClient(c4, 100); d->distanceClient(c1,c2, 10); d->distanceClient(c2,c3, 140); d->distanceClient(c3,c4, 10); d->distanceClient(c2,c1, 10); d->distanceClient(c3,c2, 140); d->distanceClient(c4,c3, 10); d->setKTransport(2); std::cout << "Generation de la solution:" << endl; s.generate(); std::cout << s << endl; std::cout << "Difference de sol: " << s.computeDifference() << endl; std::cout << s << endl; std::cout << "Coût total de la solution: " << s.getValeur() << endl; std::cout << "Fini"<<"\n"; }
KeyPair KeyGenerator::generate(const Data &entropy) { return generate(&*entropy.begin(), entropy.size()); }
void VolatileTextureMgr::reloadAllTextures() { _isReloading = true; // we need to release all of the glTextures to avoid collisions of texture id's when reloading the textures onto the GPU for(auto iter = _textures.begin(); iter != _textures.end(); ++iter) { (*iter)->_texture->releaseGLTexture(); } CCLOG("reload all texture"); auto iter = _textures.begin(); while (iter != _textures.end()) { VolatileTexture *vt = *iter++; switch (vt->_cashedImageType) { case VolatileTexture::kImageFile: { Image* image = new (std::nothrow) Image(); Data data = FileUtils::getInstance()->getDataFromFile(vt->_fileName); if (image && image->initWithImageData(data.getBytes(), data.getSize())) { Texture2D::PixelFormat oldPixelFormat = Texture2D::getDefaultAlphaPixelFormat(); Texture2D::setDefaultAlphaPixelFormat(vt->_pixelFormat); vt->_texture->initWithImage(image); Texture2D::setDefaultAlphaPixelFormat(oldPixelFormat); } CC_SAFE_RELEASE(image); } break; case VolatileTexture::kImageData: { vt->_texture->initWithData(vt->_textureData, vt->_dataLen, vt->_pixelFormat, vt->_textureSize.width, vt->_textureSize.height, vt->_textureSize); } break; case VolatileTexture::kString: { vt->_texture->initWithString(vt->_text.c_str(), vt->_fontDefinition); } break; case VolatileTexture::kImage: { vt->_texture->initWithImage(vt->_uiImage); } break; default: break; } if (vt->_hasMipmaps) { vt->_texture->generateMipmap(); } vt->_texture->setTexParameters(vt->_texParams); } _isReloading = false; }
void reset(Data * p) { if (ptr) ptr->release(); ptr = p; }
void PolycodeTextEditor::saveFile() { Data *data = new Data(); data->setFromString(textInput->getText(), String::ENCODING_UTF8); data->saveToFile(filePath); delete data; }
Data Binning::process(Data &aData) { Data aNewData = aData; if(aData.dimensions.size() != 2) throw ProcessException("Binning : Only manage 2D data"); else if(!aData.empty()) { std::stringstream info; info << "Binning " << mXFactor << " by " << mYFactor; Stat aStat(aNewData,info.str()); if(mYFactor > 0 && mXFactor > 0) { if(((mXFactor == 2 && mYFactor == 2) || (mXFactor == 4 && mYFactor == 4) || (mXFactor == 8 && mYFactor == 8) || (mXFactor == 16 && mYFactor == 16) || (mXFactor == 32 && mYFactor == 32)) && // Factor 2 (Most used) !(aData.dimensions[0] % mXFactor) && !(aData.dimensions[1] % mYFactor)) { if(!_processingInPlaceFlag) { int aNewSize = aData.size() / (mYFactor * mXFactor); Buffer *aNewBuffer = new Buffer(aNewSize); aNewData.setBuffer(aNewBuffer); aNewBuffer->unref(); } switch(aData.type) { case Data::UINT8: _binning2x2<unsigned char>(aData,aNewData,mXFactor);break; case Data::UINT16: _binning2x2<unsigned short>(aData,aNewData,mXFactor);break; case Data::UINT32: _binning2x2<unsigned int>(aData,aNewData,mXFactor);break; default: throw ProcessException("Binning : Data type not managed"); break; } } else // DEFAULT case is not optimized { int newWidth = aNewData.dimensions[0] / mXFactor; int newHeight = aNewData.dimensions[1] / mYFactor; int aNewSize = aData.depth() * newWidth * newHeight; Buffer *aNewBuffer = new Buffer(aNewSize); aNewData.setBuffer(aNewBuffer); aNewBuffer->unref(); memset(aNewData.data(),0,aNewSize); aNewData.dimensions[0] /= mXFactor; aNewData.dimensions[1] /= mYFactor; switch(aData.type) { case Data::UINT8: _default_binning<unsigned char>(aData,aNewData,mXFactor,mYFactor);break; case Data::UINT16: _default_binning<unsigned short>(aData,aNewData,mXFactor,mYFactor);break; case Data::UINT32: _default_binning<unsigned int>(aData,aNewData,mXFactor,mYFactor);break; default: throw ProcessException("Binning : Data type not managed"); break; } if(_processingInPlaceFlag) memcpy(aData.data(),aNewData.data(),aNewData.size()); } } else throw ProcessException("Binning : Factor as not been set"); } else throw ProcessException("Binning : Data is empty!"); return aNewData; }
/// price_list(list of card numbers or single card number) - With /// single card number argument, return the best offer for the card /// in format (card numer,(seller,price)). If there are not any /// cards for sale, return NULL. If a list of card numbers /// is given, return list of the prices for those cards. Without any /// arguments, return the full list of all prices. NULLs are removed /// when returning a list. Data Server::price_list(const Data& args) { if(args.IsInteger()) { int card_number=args.Integer(); VAR(prices,"prices"); // Create empty return value entry: // // (card number,("",0.0)) // Data ret(card_number,Data(string(""),0.0)); // Check if there are any prices. if(!prices->HasKey(card_number)) return Null; // Price list for the card Data& P=(*prices->FindKey(args))[1]; double price,minprice=0.0; bool first=true; list<string> sellers; list<int> seller_index; // Scan through pairs P[j]=(seller,price) and find the best offer for(size_t j=0; j<P.Size(); j++) { price=P[j][1].Real(); if(first || price < minprice) { first=false; minprice=price; sellers.clear(); seller_index.clear(); sellers.push_back(P[j][0].String()); seller_index.push_back(j); } else if(price==minprice) { sellers.push_back(P[j][0].String()); seller_index.push_back(j); } } ret[1][1]=minprice; if(sellers.size()==0) return Null; else if(sellers.size()==1) ret[1][0]=sellers.front(); else ret[1][0]=string(ToString(sellers.size())+" sellers"); return ret; } else if(args.IsList()) { Data ret; ret.MakeList(); Data e; for(size_t i=0; i<args.Size(); i++) { e=price_list(args[i]); if(!e.IsNull()) ret.AddList(e); } return ret; } else if(args.IsNull()) { VAR(prices,"prices"); return price_list(prices->Keys()); } else ArgumentError("price_list",args); return Null; }
int Ardb::GetValueByPattern(Context& ctx, const Slice& pattern, Data& subst, Data& value, ValueObjectMap* meta_cache) { const char *p, *f; const char* spat; /* If the pattern is "#" return the substitution object itself in order * to implement the "SORT ... GET #" feature. */ spat = pattern.data(); if (spat[0] == '#' && spat[1] == '\0') { value = subst; return 0; } /* If we can't find '*' in the pattern we return NULL as to GET a * fixed key does not make sense. */ p = strchr(spat, '*'); if (!p) { return -1; } std::string vstr; subst.GetDecodeString(vstr); f = strstr(spat, "->"); if (NULL != f && (uint32) (f - spat) == (pattern.size() - 2)) { f = NULL; } std::string keystr(pattern.data(), pattern.size()); string_replace(keystr, "*", vstr); if (f == NULL) { /* * keystr = "len(...)" */ if (keystr.find("len(") == 0 && keystr.rfind(")") == keystr.size() - 1) { keystr = keystr.substr(4, keystr.size() - 5); KeyType keytype = KEY_END; GetType(ctx, keystr, keytype); switch (keytype) { case SET_META: { SetLen(ctx, keystr); break; } case LIST_META: { ListLen(ctx, keystr); break; } case ZSET_META: { ZSetLen(ctx, keystr); break; } default: { return -1; } } value.SetInt64(ctx.reply.integer); value.ToString(); return 0; } ValueObject vv; int ret = StringGet(ctx, keystr, vv); if (0 == ret) { value = vv.meta.str_value; //value.ToString(); } return ret; } else { size_t pos = keystr.find("->"); std::string field = keystr.substr(pos + 2); keystr = keystr.substr(0, pos); int ret = 0; if (NULL == meta_cache) { ret = HashGet(ctx, keystr, field, value); } else { ValueObjectMap::iterator fit = meta_cache->find(keystr); if (fit == meta_cache->end()) { ValueObject meta; GetMetaValue(ctx, keystr, HASH_META, meta); fit = meta_cache->insert(ValueObjectMap::value_type(keystr, meta)).first; } Data ff; ff.SetString(field, true); ret = HashGet(ctx, fit->second, ff, value); } //value.ToString(); return ret; } }
/// get_card_data(user,card list) - Return a list of full update entries for cards given. /// check the validity of all arguments and return NULL if some of the arguments /// are not valid. Data Server::get_card_data(const Data& args) { if(!args.IsList(2) || !args[0].IsString()) ArgumentError("get_card_data",args); if(!IsUser(args[0])) throw LangErr("get_card_data","invalid user "+args.String()); if(!args[1].IsList()) return Data(); VAR(collection,"users"); MAP(collection,args[0]); VEC(collection,2); const Data& L=args[1]; Data ret; ret.MakeList(); Data entry; entry.MakeList(5); Data price; Data* card_data; for(size_t i=0; i<L.Size(); i++) { if(!L[i].IsInteger()) return Data(); int card=L[i].Integer(); if(card < 0) return Data(); // Get price data price=price_list(L[i]); if(price.IsNull()) { entry[1]=0.0; entry[2]=""; } else { entry[1]=price[1][1]; entry[2]=price[1][0]; } // Get collection data if(collection->HasKey(L[i])) { MAPTO(collection,L[i],card_data); entry[0]=(*card_data)[0]; entry[3]=(*card_data)[2]; entry[4]=(*card_data)[1]; } else { entry[0]=0; entry[3]=0.0; entry[4]=0; } ret.AddList(Data(L[i],entry)); } if(ret.Size()) return ret; return Data(); }
Data Data::operator -(const Data &data) const { if(data.type == Data::INT) { Data ret(Data::INT); ret.value.i = this->value.i - data.value.i; return ret; } if(!(*this >= data)) { throw QString("Runtime error: invalid subtraction of multisets " + this->toString() + " - " + data.toString() ); } if(data.type == Data::MULTIUNIT) { Data ret(Data::MULTIUNIT); ret.value.multiUnit = this->value.multiUnit - data.value.multiUnit; return ret; } else if(data.type == Data::MULTIBOOL) { Data ret(Data::MULTIBOOL); ret.value.multiBool.t = this->value.multiBool.t - data.value.multiBool.t; ret.value.multiBool.f = this->value.multiBool.f - data.value.multiBool.f; return ret; } else if(data.type == Data::MULTIINT) { Data ret(Data::MULTIINT); QMapIterator<int, int>i(*this->value.multiInt); while(i.hasNext()) { i.next(); ret.value.multiInt->insert(i.key(), i.value()); } QMapIterator<int, int>j(*data.value.multiInt); while(j.hasNext()) { j.next(); (*ret.value.multiInt)[j.key()] -= j.value(); if((*ret.value.multiInt)[j.key()] == 0) (*ret.value.multiInt).remove(j.key()); } return ret; } Q_ASSERT(false); return Data(); }
bool Interest::matchesData(const Data& data) const { size_t interestNameLength = m_name.size(); const Name& dataName = data.getName(); size_t fullNameLength = dataName.size() + 1; // check MinSuffixComponents bool hasMinSuffixComponents = getMinSuffixComponents() >= 0; size_t minSuffixComponents = hasMinSuffixComponents ? static_cast<size_t>(getMinSuffixComponents()) : 0; if (!(interestNameLength + minSuffixComponents <= fullNameLength)) return false; // check MaxSuffixComponents bool hasMaxSuffixComponents = getMaxSuffixComponents() >= 0; if (hasMaxSuffixComponents && !(interestNameLength + getMaxSuffixComponents() >= fullNameLength)) return false; // check prefix if (interestNameLength == fullNameLength) { if (m_name.get(-1).isImplicitSha256Digest()) { if (m_name != data.getFullName()) return false; } else { // Interest Name is same length as Data full Name, but last component isn't digest // so there's no possibility of matching return false; } } else { // Interest Name is a strict prefix of Data full Name if (!m_name.isPrefixOf(dataName)) return false; } // check Exclude // Exclude won't be violated if Interest Name is same as Data full Name if (!getExclude().empty() && fullNameLength > interestNameLength) { if (interestNameLength == fullNameLength - 1) { // component to exclude is the digest if (getExclude().isExcluded(data.getFullName().get(interestNameLength))) return false; // There's opportunity to inspect the Exclude filter and determine whether // the digest would make a difference. // eg. "<NameComponent>AA</NameComponent><Any/>" doesn't exclude any digest - // fullName not needed; // "<Any/><NameComponent>AA</NameComponent>" and // "<Any/><ImplicitSha256DigestComponent>ffffffffffffffffffffffffffffffff // </ImplicitSha256DigestComponent>" // excludes all digests - fullName not needed; // "<Any/><ImplicitSha256DigestComponent>80000000000000000000000000000000 // </ImplicitSha256DigestComponent>" // excludes some digests - fullName required // But Interests that contain the exact Data Name before digest and also // contain Exclude filter is too rare to optimize for, so we request // fullName no mater what's in the Exclude filter. } else { // component to exclude is not the digest if (getExclude().isExcluded(dataName.get(interestNameLength))) return false; } } // check PublisherPublicKeyLocator const KeyLocator& publisherPublicKeyLocator = this->getPublisherPublicKeyLocator(); if (!publisherPublicKeyLocator.empty()) { const Signature& signature = data.getSignature(); const Block& signatureInfo = signature.getInfo(); Block::element_const_iterator it = signatureInfo.find(tlv::KeyLocator); if (it == signatureInfo.elements_end()) { return false; } if (publisherPublicKeyLocator.wireEncode() != *it) { return false; } } return true; }
Data Mask::process(Data &aData) { #define _INPLACE(data,size,datamask) \ if(_type == Mask::STANDARD) \ _mask_inplace(data,size,datamask); \ else \ _dummy_inplace(data,size,datamask); #define _COPY(src,dst,size,datamask) \ if(_type == Mask::STANDARD) \ _mask(src,dst,size,datamask); \ else \ _dummy(src,dst,size,datamask); const char *errorMsgPt = NULL; if(aData.dimensions == _MaskImage.dimensions) { if(_processingInPlaceFlag) { switch(aData.type) { case Data::UINT8: if(aData.type == _MaskImage.type) { _INPLACE((unsigned char*)aData.data(),aData.size(), (unsigned char*)_MaskImage.data()); } else { errorMsgPt = "mask image must be an unsigned char"; goto error; } break; case Data::UINT16: switch(_MaskImage.type) { case Data::UINT8: _INPLACE((unsigned short*)aData.data(),aData.size(), (unsigned char*)_MaskImage.data()); break; case Data::UINT16: _INPLACE((unsigned short*)aData.data(),aData.size(), (unsigned short*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char or unsigned short"; goto error; } break; case Data::UINT32: switch(_MaskImage.type) { case Data::UINT8: _INPLACE((unsigned int*)aData.data(),aData.size(), (unsigned char*)_MaskImage.data()); break; case Data::UINT16: _INPLACE((unsigned int*)aData.data(),aData.size(), (unsigned short*)_MaskImage.data()); break; case Data::UINT32: _INPLACE((unsigned int*)aData.data(),aData.size(), (unsigned int*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char,unsigned short or unsigned int"; goto error; } break; case Data::INT32: switch(_MaskImage.type) { case Data::UINT8: _INPLACE((int*)aData.data(),aData.size(), (unsigned char*)_MaskImage.data()); break; case Data::UINT16: _INPLACE((int*)aData.data(),aData.size(), (unsigned short*)_MaskImage.data()); break; case Data::UINT32: _INPLACE((int*)aData.data(),aData.size(), (unsigned int*)_MaskImage.data()); break; case Data::INT32: _INPLACE((int*)aData.data(),aData.size(), (int*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char,unsigned short,unsigned int or int"; goto error; } break; default: errorMsgPt = "Data type not managed"; goto error; } return aData; } else { Data aNewData = aData.copyHeader(aData.type); // get a new data buffer switch(aData.type) { case Data::UINT8: if(aData.type == _MaskImage.type) { _COPY((unsigned char*)aData.data(),(unsigned char*)aNewData.data(), aData.size(),(unsigned char*)_MaskImage.data()); } else { errorMsgPt = "mask image must be an unsigned char"; goto error; } break; case Data::UINT16: switch(_MaskImage.type) { case Data::UINT8: _COPY((unsigned short*)aData.data(),(unsigned short*)aNewData.data(), aData.size(),(unsigned char*)_MaskImage.data()); break; case Data::UINT16: _COPY((unsigned short*)aData.data(),(unsigned short*)aNewData.data(), aData.size(), (unsigned short*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char or unsigned short"; goto error; } break; case Data::UINT32: switch(_MaskImage.type) { case Data::UINT8: _COPY((unsigned int*)aData.data(),(unsigned int*)aNewData.data(), aData.size(), (unsigned char*)_MaskImage.data()); break; case Data::UINT16: _COPY((unsigned int*)aData.data(),(unsigned int*)aNewData.data(), aData.size(), (unsigned short*)_MaskImage.data()); break; case Data::UINT32: _COPY((unsigned int*)aData.data(),(unsigned int*)aNewData.data(), aData.size(), (unsigned int*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char,unsigned short or unsigned int"; goto error; } case Data::INT32: switch(_MaskImage.type) { case Data::UINT8: _COPY((int*)aData.data(),(int*)aNewData.data(), aData.size(), (unsigned char*)_MaskImage.data()); break; case Data::UINT16: _COPY((int*)aData.data(),(int*)aNewData.data(), aData.size(), (unsigned short*)_MaskImage.data()); break; case Data::INT32: _COPY((int*)aData.data(),(int*)aNewData.data(), aData.size(), (int*)_MaskImage.data()); break; case Data::UINT32: _COPY((int*)aData.data(),(int*)aNewData.data(), aData.size(), (unsigned int*)_MaskImage.data()); break; default: errorMsgPt = "mask image must be an unsigned char,unsigned short,unsigned int or int"; goto error; } break; default: errorMsgPt = "Data type not managed"; goto error; } return aNewData; } } else errorMsgPt = "Source image differ from mask image"; error: if(errorMsgPt) { char aBuffer[256]; snprintf(aBuffer,sizeof(aBuffer),"Mask : %s",errorMsgPt); throw ProcessException(aBuffer); } return Data(); }
static Data getData(const std::string& filename, bool forString) { if (filename.empty()) { return Data::Null; } Data ret; unsigned char* buffer = nullptr; ssize_t size = 0; const char* mode = nullptr; if (forString) mode = "rt"; else mode = "rb"; do { // Read the file from hardware std::string fullPath = FileUtils::getInstance()->fullPathForFilename(filename); FILE *fp = fopen(fullPath.c_str(), mode); CC_BREAK_IF(!fp); fseek(fp,0,SEEK_END); size = ftell(fp); fseek(fp,0,SEEK_SET); if (forString) { buffer = (unsigned char*)malloc(sizeof(unsigned char) * (size + 1)); buffer[size] = '\0'; } else { buffer = (unsigned char*)malloc(sizeof(unsigned char) * size); } size = fread(buffer, sizeof(unsigned char), size, fp); fclose(fp); } while (0); // add for resource pack by R.R. if (buffer && size > 0) { if (XXTEAUtil::getInstance()->isXXTEA(buffer, size)) { int len = 0; unsigned char *result = XXTEAUtil::getInstance()->decrypt(buffer, size, len); free(buffer); buffer = result; size = len; } } if (nullptr == buffer || 0 == size) { std::string msg = "Get data from file("; msg.append(filename).append(") failed!"); CCLOG("%s", msg.c_str()); } else { ret.fastSet(buffer, size); } return ret; }