void Framework::update(){
//最初のフレームにファイル読み込み
if ( gFirst ){
gFirst = false;
char* buffer = 0;
int size = 0;
readFile( &buffer, &size, "bar.dds" );
gImageHeight = getUnsigned( &( buffer[ 12 ] ) );
gImageWidth = getUnsigned( &( buffer[ 16 ] ) );
gImageData = new unsigned[ gImageWidth * gImageHeight ];
for ( int i = 0; i < gImageWidth * gImageHeight; ++i ){
gImageData[ i ] = getUnsigned( &( buffer[ 128 + i * 4 ] ) );
}
}
unsigned* vram = videoMemory();
int windowWidth = width();
int windowHeight = height();
int partX = 0;
int partY = 1;
//適当に32x32の領域で敷き詰めます。
for ( int tileY = 0; tileY + 32 < windowHeight; tileY += 32 ){
for ( int tileX = 0; tileX + 32 < windowWidth; tileX += 32 ){
for ( int y = 0; y < 32; ++y ){
for ( int x = 0; x < 32; ++x ){
unsigned* dst = &vram[ ( tileY + y ) * windowWidth + ( tileX + x ) ];
*dst = gImageData[ ( partY * 32 + y ) * gImageWidth + ( partX * 32 + x ) ];
}
}
//適当にタイルを選択。数字に根拠はない。
partX = ( partX + 9973 ) % 4;
partY = ( partY + 9967 ) % 4;
}
}
}
// Store name, city, and rating (between MIN_RATING to MAX_RATING inclusive)
// from user input for a given number of resorts
struct resortType* getResorts(unsigned num) {
if (!num) {
return NULL;
}
char* error;
// Allow alphanumeric characters and spaces
char* alphaNumericFilter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
struct resortType* resorts = calloc(num, sizeof(struct resortType));
if (!resorts) {
return NULL;
}
// Interate through resort array getting information for each entry
for (unsigned i = 0; i < num; i++) {
printf("Resort #%u:\n", i + 1);
resorts[i].name = getFilteredString("\tEnter resort name:\n", alphaNumericFilter, &error);
if (!resorts[i].name) {
resorts[i].name = "";
printf("%s\n", error);
}
resorts[i].city = getFilteredString("\tEnter city name:\n", alphaNumericFilter, &error);
if (!resorts[i].city) {
resorts[i].city = "";
printf("%s\n", error);
}
printf("\tEnter resort rating:\n");
resorts[i].rating = getUnsigned();
if (resorts[i].rating < MIN_RATING || resorts[i].rating > MAX_RATING) {
resorts[i].rating = UNACCEPTABLE;
}
}
return resorts;
}
//------------------------------------------------------------------------
//--- JetCorrectorParameters::Record constructor -------------------------
//--- reads the member variables from a string ---------------------------
//------------------------------------------------------------------------
JetCorrectorParameters::Record::Record(const std::string& fLine,unsigned fNvar) : mMin(0),mMax(0)
{
mNvar = fNvar;
// quckly parse the line
std::vector<std::string> tokens = getTokens(fLine);
if (!tokens.empty())
{
if (tokens.size() < 3)
{
std::stringstream sserr;
sserr<<"(line "<<fLine<<"): "<<"three tokens expected, "<<tokens.size()<<" provided.";
handleError("JetCorrectorParameters::Record",sserr.str());
}
for(unsigned i=0;i<mNvar;i++)
{
mMin.push_back(getFloat(tokens[i*mNvar]));
mMax.push_back(getFloat(tokens[i*mNvar+1]));
}
unsigned nParam = getUnsigned(tokens[2*mNvar]);
if (nParam != tokens.size()-(2*mNvar+1))
{
std::stringstream sserr;
sserr<<"(line "<<fLine<<"): "<<tokens.size()-(2*mNvar+1)<<" parameters, but nParam="<<nParam<<".";
handleError("JetCorrectorParameters::Record",sserr.str());
}
for (unsigned i = (2*mNvar+1); i < tokens.size(); ++i)
mParameters.push_back(getFloat(tokens[i]));
}
}
unsigned ClimateZone::year() const {
OS_ASSERT(!empty());
OptionalUnsigned ou = getUnsigned(OS_ClimateZonesExtensibleFields::ClimateZoneDocumentYear,true);
if (!ou) {
LOG_AND_THROW("Climate zone year is not yet set for the " << groupIndex() << "th ClimateZone.");
}
return *ou;
}
/* Throws std::invalid_argument if a value for key is not found */
unsigned long Properties::getPositiveNumber(const std::string& key) const
{
unsigned long result;
result = getUnsigned(key);
if(result == 0){
throw std::invalid_argument(key + " Property value set to 0");
}
return result;
}
//-----------------------------------------------------------------------------
// checks the checksum out of the binary data,
// buffer and, packetLength must be correctly initialised
bool CCSDS::PACKET::Packet::checkChecksum() const throw(UTIL::Exception)
//-----------------------------------------------------------------------------
{
if(!checkPacketLength())
{
return false;
}
size_t crcPos = bufferSize() - 2;
uint16_t crc = UTIL::CRC::calculate16(buffer(), crcPos);
return (getUnsigned(crcPos, 2) == crc);
}
unsigned long Properties::getPositiveNumber(const std::string& key,
unsigned long defaultValue) const
{
unsigned long result;
result = getUnsigned(key,defaultValue);
if(result == 0){
Log::log(logID, Log::LOG_MAX_DEBUG,"Property [%s] value set to 0",key.c_str());
result = defaultValue;
Log::log(logID, Log::LOG_MAX_DEBUG,"Resetting Property [%s] value back to default : %d",key.c_str(),defaultValue);
}
return result;
}
//------------------------------------------------------------------------
//--- JetCorrectorParameters::Definitions constructor --------------------
//--- reads the member variables from a string ---------------------------
//------------------------------------------------------------------------
JetCorrectorParameters::Definitions::Definitions(const std::string& fLine)
{
std::vector<std::string> tokens = getTokens(fLine);
if (!tokens.empty())
{
if (tokens.size() < 6)
{
std::stringstream sserr;
sserr<<"(line "<<fLine<<"): less than 6 expected tokens:"<<tokens.size();
handleError("JetCorrectorParameters::Definitions",sserr.str());
}
unsigned nvar = getUnsigned(tokens[0]);
unsigned npar = getUnsigned(tokens[nvar+1]);
for(unsigned i=0;i<nvar;i++)
mBinVar.push_back(tokens[i+1]);
for(unsigned i=0;i<npar;i++)
mParVar.push_back(tokens[nvar+2+i]);
mFormula = tokens[npar+nvar+2];
std::string ss = tokens[npar+nvar+3];
if (ss == "Response")
mIsResponse = true;
else if (ss == "Correction")
mIsResponse = false;
else if (ss == "Resolution")
mIsResponse = false;
else if (ss.find("PAR")==0)
mIsResponse = false;
else
{
std::stringstream sserr;
sserr<<"unknown option ("<<ss<<")";
handleError("JetCorrectorParameters::Definitions",sserr.str());
}
mLevel = tokens[npar+nvar+4];
}
}
uint64_t getu64_t(const char *arg, int32_t flags, const char *varName)/*#{{{*/
{
register unsigned long long res = 0;
res = getUnsigned("getu64_t", arg, flags, varName);
/* make sure the converted number is in the range of an uint64_t */
if(res > UINT64_MAX){ /* checks for unsigned in getNum */
if(flags & GN_NOEXIT_){
fprintf(stderr,"\nInteger was out of range\n");
errno = EINVAL;
return 0;}
else{
gnFail("getUnsigned", "integer out of range", arg, varName);}
}
return (uint64_t) res;
} /* end get64_t #}}} */
Date::Date(const std::string& str, const std::string& fmt)
{
unsigned year = 0;
unsigned month = 1;
unsigned day = 1;
enum {
state_0,
state_fmt,
state_two
} state = state_0;
try
{
std::string::const_iterator dit = str.begin();
std::string::const_iterator it;
for (it = fmt.begin(); it != fmt.end() && dit != str.end(); ++it)
{
char ch = *it;
switch (state)
{
case state_0:
if (ch == '%')
state = state_fmt;
else
{
if (ch == '*')
skipNonDigit(dit, str.end());
else if (*dit != ch && ch != '?')
throw InvalidDate("string <" + str + "> does not match date format <" + fmt + '>');
else
++dit;
}
break;
case state_fmt:
if (*it != '%')
state = state_0;
switch (ch)
{
case 'Y':
year = getInt(dit, str.end(), 4);
break;
case 'y':
year = getInt(dit, str.end(), 2);
year += (year < 50 ? 2000 : 1900);
break;
case 'm':
month = getUnsigned(dit, str.end(), 2);
break;
case 'd':
day = getUnsigned(dit, str.end(), 2);
break;
case '2':
state = state_two;
break;
default:
throw InvalidDate("invalid date format <" + fmt + '>');
}
break;
case state_two:
state = state_0;
switch (ch)
{
case 'm': month = getUnsignedF(dit, str.end(), 2); break;
case 'd': day = getUnsignedF(dit, str.end(), 2); break;
default:
throw InvalidDate("invalid date format <" + fmt + '>');
}
}
}
if (it != fmt.end() || dit != str.end())
throw InvalidDate("string <" + str + "> does not match date format <" + fmt + '>');
set(year, month, day);
}
catch (const std::invalid_argument&)
{
throw InvalidDate("string <" + str + "> does not match date format <" + fmt + '>');
}
}
Parameters::Parameters(std::string fileName) {
std::ifstream configFile(fileName.c_str());
spreadEntry = getDouble(getParameter("SpreadEntry", configFile));
spreadTarget = getDouble(getParameter("SpreadTarget", configFile));
maxLength = getUnsigned(getParameter("MaxLength", configFile));
priceDeltaLim = getDouble(getParameter("PriceDeltaLimit", configFile));
trailingLim = getDouble(getParameter("TrailingSpreadLim", configFile));
trailingCount = getUnsigned(getParameter("TrailingSpreadCount", configFile));
orderBookFactor = getDouble(getParameter("OrderBookFactor", configFile));
demoMode = getBool(getParameter("DemoMode", configFile));
verbose = getBool(getParameter("Verbose", configFile));
gapSec = getUnsigned(getParameter("GapSec", configFile));
debugMaxIteration = getUnsigned(getParameter("DebugMaxIteration", configFile));
useFullCash = getBool(getParameter("UseFullCash", configFile));
untouchedCash = getDouble(getParameter("UntouchedCash", configFile));
cashForTesting = getDouble(getParameter("CashForTesting", configFile));
maxExposure = getDouble(getParameter("MaxExposure", configFile));
useVolatility = getBool(getParameter("UseVolatility", configFile));
volatilityPeriod = getUnsigned(getParameter("VolatilityPeriod", configFile));
bitfinexApi = getParameter("BitfinexApiKey", configFile);
bitfinexSecret = getParameter("BitfinexSecretKey", configFile);
bitfinexFees = getDouble(getParameter("BitfinexFees", configFile));
okcoinApi = getParameter("OkCoinApiKey", configFile);
okcoinSecret = getParameter("OkCoinSecretKey", configFile);
okcoinFees = getDouble(getParameter("OkCoinFees", configFile));
bitstampClientId = getParameter("BitstampClientId", configFile);
bitstampApi = getParameter("BitstampApiKey", configFile);
bitstampSecret = getParameter("BitstampSecretKey", configFile);
bitstampFees = getDouble(getParameter("BitstampFees", configFile));
geminiApi = getParameter("GeminiApiKey", configFile);
geminiSecret = getParameter("GeminiSecretKey", configFile);
geminiFees = getDouble(getParameter("GeminiFees", configFile));
krakenApi = getParameter("KrakenApiKey", configFile);
krakenSecret = getParameter("KrakenSecretKey", configFile);
krakenFees = getDouble(getParameter("KrakenFees", configFile));
itbitApi = getParameter("ItBitApiKey", configFile);
itbitSecret = getParameter("ItBitSecretKey", configFile);
itbitFees = getDouble(getParameter("ItBitFees", configFile));
btceApi = getParameter("BTCeApiKey", configFile);
btceSecret = getParameter("BTCeSecretKey", configFile);
btceFees = getDouble(getParameter("BTCeFees", configFile));
sevennintysixAppId = getParameter("SevenNintySixAppId", configFile);
sevennintysixApi = getParameter("SevenNintySixApiKey", configFile);
sevennintysixSecret = getParameter("SevenNintySixSecretKey", configFile);
sevennintysixFees = getDouble(getParameter("SevenNintySixFees", configFile));
sendEmail = getBool(getParameter("SendEmail", configFile));
senderAddress = getParameter("SenderAddress", configFile);
senderUsername = getParameter("SenderUsername", configFile);
senderPassword = getParameter("SenderPassword", configFile);
smtpServerAddress = getParameter("SmtpServerAddress", configFile);
receiverAddress = getParameter("ReceiverAddress", configFile);
useDatabase = getBool(getParameter("UseDatabase", configFile));
dbHost = getParameter("DBHost", configFile);
dbName = getParameter("DBName", configFile);
dbUser = getParameter("DBUser", configFile);
dbPassword = getParameter("DBPassword", configFile);
configFile.close();
}
unsigned GasMixture_Impl::numGases() const {
OptionalUnsigned ou = getUnsigned(OS_WindowMaterial_GasMixtureFields::NumberofGasesinMixture,true);
OS_ASSERT(ou);
return *ou;
}
Time::Time(const std::string& str, const std::string& fmt)
: _msecs(0)
{
unsigned hours = 0;
unsigned minutes = 0;
unsigned seconds = 0;
unsigned mseconds = 0;
bool am = true;
enum {
state_0,
state_fmt
} state = state_0;
std::string::const_iterator dit = str.begin();
std::string::const_iterator it;
for (it = fmt.begin(); it != fmt.end(); ++it)
{
char ch = *it;
switch (state)
{
case state_0:
if (ch == '%')
state = state_fmt;
else
{
if (dit == str.end() || *dit != ch)
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
++dit;
}
break;
case state_fmt:
switch (ch)
{
case 'H':
case 'I':
hours = getUnsigned(dit, str.end(), 2);
break;
case 'M':
minutes = getUnsigned(dit, str.end(), 2);
break;
case 'S':
seconds = getUnsigned(dit, str.end(), 2);
break;
case 'j':
if (dit != str.end() && *dit == '.')
++dit;
mseconds = getMilliseconds(dit, str.end());
break;
case 'J':
case 'K':
if (dit != str.end() && *dit == '.')
{
++dit;
mseconds = getMilliseconds(dit, str.end());
}
break;
case 'k':
mseconds = getMilliseconds(dit, str.end());
break;
case 'p':
if (dit == str.end()
|| dit + 1 == str.end()
|| ((*dit != 'A'
&& *dit != 'a'
&& *dit != 'P'
&& *dit != 'p')
|| (*(dit + 1) != 'M'
&& *(dit + 1) != 'm')))
{
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
}
am = (*dit == 'A' || *dit == 'a');
dit += 2;
break;
default:
throw std::runtime_error("invalid time format <" + fmt + '>');
}
state = state_0;
break;
}
}
if (it != fmt.end() || dit != str.end())
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
set(am ? hours : hours + 12, minutes, seconds, mseconds);
}
