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;
}
