void FllImporter::processOutputVariable(const std::string& block, Engine* engine) const {
std::istringstream reader(block);
std::string line;
OutputVariable* outputVariable = new OutputVariable;
engine->addOutputVariable(outputVariable);
while (std::getline(reader, line)) {
std::pair<std::string, std::string> keyValue = parseKeyValue(line, ':');
if ("OutputVariable" == keyValue.first) {
outputVariable->setName(keyValue.second);
} else if ("enabled" == keyValue.first) {
outputVariable->setEnabled(parseBoolean(keyValue.second));
} else if ("range" == keyValue.first) {
std::pair<scalar, scalar> range = parseRange(keyValue.second);
outputVariable->setRange(range.first, range.second);
} else if ("default" == keyValue.first) {
outputVariable->setDefaultValue(Op::toScalar(keyValue.second));
} else if ("lock-valid" == keyValue.first) {
outputVariable->setLockValidOutput(parseBoolean(keyValue.second));
} else if ("lock-range" == keyValue.first) {
outputVariable->setLockOutputRange(parseBoolean(keyValue.second));
} else if ("defuzzifier" == keyValue.first) {
outputVariable->setDefuzzifier(parseDefuzzifier(keyValue.second));
} else if ("accumulation" == keyValue.first) {
outputVariable->fuzzyOutput()->setAccumulation(parseSNorm(keyValue.second));
} else if ("term" == keyValue.first) {
outputVariable->addTerm(parseTerm(keyValue.second, engine));
} else {
throw fl::Exception("[import error] key <" + keyValue.first + "> not "
"recognized in pair <" + keyValue.first + ":" + keyValue.second + ">", FL_AT);
}
}
}
void Config::constructUnitWithXML(Unit* unit, xmlNodePtr node)
{
xmlChar* szid = xmlGetProp(node, BAD_CAST"id");
xmlChar* szname = xmlGetProp(node, BAD_CAST"name");
xmlChar* szlevel = xmlGetProp(node, BAD_CAST"level");
xmlChar* szAI = xmlGetProp(node, BAD_CAST"ai");
xmlChar* szAlign = xmlGetProp(node, BAD_CAST"alignment");
xmlChar* szMaxHealth = xmlGetProp(node, BAD_CAST"maxHealth");
xmlChar* szAgility = xmlGetProp(node, BAD_CAST"agility");
xmlChar* szSkills = xmlGetProp(node, BAD_CAST"skills");
xmlChar* szAttackFreq = xmlGetProp(node, BAD_CAST"attackFreq");
xmlChar* szAttackRange = xmlGetProp(node, BAD_CAST"attackRange");
xmlChar *szView = xmlGetProp(node, BAD_CAST"view");
unit->cid = atoi((const char*)szid);
unit->name = (char*)szname;
unit->maxHealth = atoi((const char*)szMaxHealth);
unit->agility = atoi((const char*)szAgility);
unit->ai = atoi((const char*)szAI);
unit->alignment = atoi((const char*)szAlign);
parseSkills(unit,szSkills);
unit->attackFreq = atoi((const char*)szAttackFreq);
parseRange(unit, szAttackRange);
parseView(unit, szView);
}
void BlobResourceHandle::doStart()
{
// Do not continue if the request is aborted or an error occurs.
if (m_aborted || m_errorCode)
return;
// If the blob data is not found, fail now.
if (!m_blobData) {
m_errorCode = notFoundError;
notifyResponse();
return;
}
// Parse the "Range" header we care about.
String range = firstRequest().httpHeaderField("Range");
if (!range.isEmpty() && !parseRange(range, m_rangeOffset, m_rangeEnd, m_rangeSuffixLength)) {
m_errorCode = rangeError;
notifyResponse();
return;
}
if (m_async)
getSizeForNext();
else {
for (size_t i = 0; i < m_blobData->items().size() && !m_aborted && !m_errorCode; ++i)
getSizeForNext();
notifyResponse();
}
}
int RtspClientSession::handle_play(RtspClientConnection * rcc,
MediaSubSession * subSession,
std::string & fullRequestStr){
std::string strScale;
//parse scale
size_type pos = fullRequestStr.find("Scale:");
if(pos != std::string::npos){
pos += 5;
while(fullRequestStr[++pos] == ' ');
float fscale = (float)atof(fullRequestStr.c_str() + pos);
append(strScale, "Scale: %f\r\n", fscale);
}
const ipaddr & localAddr = rcc->get_localaddr();
std::string rtspUrl;
append(rtspUrl, "RTP-Info: rtsp://%s:%u/%s/%s;seq=%u//;rtptime=%u",
localAddr.ip, watcher::instance()->tcp_port(),
m_mediaSession->StreamName().c_str(),
subSession->GetTrackId().c_str(),
subSession->SeqNo(),
subSession->RtpTimestamp());
std::string absstart, absend;
double startTime = 0, endTime = 0;
int result = parseRange(fullRequestStr, absstart, absend, startTime, endTime);
std::string response;
append(response,
"RTSP/1.0 200 OK\r\n"
"CSeq: %s\r\n"
"%s"
"%s"
"Session: %s\r\n"
"%s\r\n\r\n",
rcc->getSeq().c_str(),
dateStr().c_str(),
strScale.c_str(),
m_sessionId.c_str(),
rtspUrl.c_str());
if(result < 0){
}
debug_log("play: %s\n", response.c_str());
rcc->post_send(response.c_str(), response.length());
subSession->StartStream(rcc->get_rtsp());
return 0;
}
void decodeXYZdata(char *response, float *bigX, float *bigY, float *bigZ, float *xChroma, float *yChroma, float *YLum, int *redRange, int *greenRange, int *blueRange)
{
int charIndex;
/* Decode X */
charIndex = 2;
*bigX = string3ToFloat(response, charIndex);
/* Decode Y */
charIndex = 5;
*bigY = string3ToFloat(response, charIndex);
/* Decode Z */
charIndex = 8;
*bigZ = string3ToFloat(response, charIndex);
float sum = (*bigX) + (*bigY) + (*bigZ);
*xChroma = *bigX / sum;
*yChroma = *bigY / sum;
*YLum = *bigY;
/* Decode range */
int ranges[3];
parseRange((unsigned char)response[11], ranges);
*redRange = ranges[0];
*greenRange = ranges[1];
*blueRange = ranges[2];
/* Decode Error */
char errorCode = response[13];
if (strncmp(&errorCode,"L",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: AIMING LIGHTS\n");
else if (strncmp(&errorCode,"u",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: BOTTOM_UNDER_RANGE\n");
else if (strncmp(&errorCode,"v",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: TOP_OVER_RANGE\n");
else if (strncmp(&errorCode,"w",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: OVER_HIGH_RANGE\n");
else if (strncmp(&errorCode,"t",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: BLACK_ZERO\n");
else if (strncmp(&errorCode,"s",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: BLACK_OVERDRIVE\n");
else if (strncmp(&errorCode,"b",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: BLACK_EXCESSIVE\n");
else if (strncmp(&errorCode,"X",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: FIRMWARE\n");
else if (strncmp(&errorCode,"B",1) == 0)
mexPrintf(">>>>>>>>>>>>>>> error code: FIRMWARE\n");
}
TreeChains parseChainString(const std::string& chainStr, bool isPrivate) {
TreeChains treeChains;
const std::string s = StringUtils::split(chainStr)[0]; //trim trailing whitespaces
std::deque<std::string> splitChain = StringUtils::split(s, '/');
//account for root node
treeChains.push_back(IsPrivateNPathRange(true , Range(NODE_IDX_M_FLAG, NODE_IDX_M_FLAG)));
if (splitChain.back() == "") splitChain.pop_back(); // happens if chainStr has '/' at end
for (std::string& node : splitChain) {
if (node.back() == '\'') {
if (! isPrivate) throw std::runtime_error("Invalid chain "+ chainStr+ ", not private extended key.");
node = node.substr(0,node.length()-1);
if (node.front() == '(' && node.back() == ')') {
IsPrivateNPathRange range = parseRange(node, true);
treeChains.push_back(range);
} else {
uint32_t num = toPrime(std::stoi(node));
treeChains.push_back(IsPrivateNPathRange(true , Range(num, num)));
}
} else {
if (node.front() == '(' && node.back() == ')') {
IsPrivateNPathRange range = parseRange(node, false);
treeChains.push_back(range);
} else {
uint32_t num = std::stoi(node);
treeChains.push_back(IsPrivateNPathRange(false , Range(num, num)));
}
}
}
return treeChains;
}
/// GPUmxAssign
void GPUmxAssign(const GPUtype &LHS, const GPUtype &RHS, int dir, int nrhs,
const mxArray *prhs[]) {
// simple garbage collection
MyGCObj<Range> mygc1;
// rg is the Range we have to populate
Range *rg;
parseRange(nrhs, &prhs[0], &rg, mygc1);
// After creating the Range, I can call
gm->gputype.mxAssign(LHS, RHS, *rg, dir);
}
/// GPUmxSlice
GPUtype GPUmxSliceDrv(const GPUtype &RHS, int nrhs,
const mxArray *prhs[]) {
// simple garbage collection
MyGCObj<Range> mygc1;
GPUtype OUT;
gpuTYPE_t trhs = gm->gputype.getType(RHS);
// rg is the Range we have to populate
Range *rg;
parseRange(nrhs,&prhs[0],&rg, mygc1);
// After creating the Range, I can call mxSlice
// mxSlice uses indexes starting from 1 (Fortran/Matlab)
OUT = gm->gputype.mxSlice(RHS,*rg);
// I have to handle some particular cases here.
// 1) The final result should have the same dimensions
// as the indexes array
// For example:
// slice(A,{[1 2;3 4]})
// size(A) = [2 2]
//
// slice(A,:) should generate a Nx1 vector (and not 1xN)
//
if (nrhs==1) {
if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {
mxArray *mx = mxGetCell(prhs[0], 0);
const mwSize * mysize = mxGetDimensions(mx);
int n = mxGetNumberOfDimensions(mx);
gm->gputype.setSize(OUT, n, mysize);
} else if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {
const int *mysize = gm->gputype.getSize(OUT);
int newsize[2];
newsize[0] = mysize[1];
newsize[1] = mysize[0];
gm->gputype.setSize(OUT, 2, newsize);
}
}
return OUT;
}
Object * parseReferenceOrRange(Collector * c, Tokenizer * tt) {
Coord * ref = NULL;
ref = parseReference(c, tt); if (!ref) goto fail;
char * sp = tt->bp;
TokenType t = tokenizerNext(tt);
if (t == TOK_COLON) {
return parseRange(c, tt, ref);
} else {
tokenizerSet(tt, sp);
}
return (Object *) ref;
fail:
return NULL;
}
void NetworkDataTaskBlob::resume()
{
ASSERT(m_state != State::Running);
if (m_state == State::Canceling || m_state == State::Completed)
return;
m_state = State::Running;
if (m_scheduledFailureType != NoFailure) {
ASSERT(m_failureTimer.isActive());
return;
}
RunLoop::main().dispatch([this, protectedThis = makeRef(*this)] {
if (m_state == State::Canceling || m_state == State::Completed || !m_client) {
clearStream();
return;
}
if (!equalLettersIgnoringASCIICase(m_firstRequest.httpMethod(), "get")) {
didFail(Error::MethodNotAllowed);
return;
}
// If the blob data is not found, fail now.
if (!m_blobData) {
didFail(Error::NotFoundError);
return;
}
// Parse the "Range" header we care about.
String range = m_firstRequest.httpHeaderField(HTTPHeaderName::Range);
if (!range.isEmpty() && !parseRange(range, m_rangeOffset, m_rangeEnd, m_rangeSuffixLength)) {
didReceiveResponse(Error::RangeError);
return;
}
getSizeForNext();
});
}
void FllImporter::processInputVariable(const std::string& block, Engine* engine) const {
std::istringstream reader(block);
std::string line;
InputVariable* inputVariable = new InputVariable;
engine->addInputVariable(inputVariable);
while (std::getline(reader, line)) {
std::pair<std::string, std::string> keyValue = parseKeyValue(line, ':');
if ("InputVariable" == keyValue.first) {
inputVariable->setName(keyValue.second);
} else if ("enabled" == keyValue.first) {
inputVariable->setEnabled(parseBoolean(keyValue.second));
} else if ("range" == keyValue.first) {
std::pair<scalar, scalar> range = parseRange(keyValue.second);
inputVariable->setRange(range.first, range.second);
} else if ("term" == keyValue.first) {
inputVariable->addTerm(parseTerm(keyValue.second, engine));
} else {
throw fl::Exception("[import error] key <" + keyValue.first + "> not "
"recognized in pair <" + keyValue.first + ":" + keyValue.second + ">", FL_AT);
}
}
}
void CRangeChooserDialog::initConnections() {
// Signals from text/list widgets
QObject::connect(m_rangeList, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
this, SLOT(editRange(QListWidgetItem*)));
QObject::connect(m_rangeEdit, SIGNAL(textChanged()),
this, SLOT(parseRange()));
QObject::connect(m_rangeEdit, SIGNAL(textChanged()),
this, SLOT(rangeChanged()));
QObject::connect(m_nameEdit, SIGNAL(textChanged(const QString&)),
this, SLOT(nameChanged(const QString&)));
// Buttons
QObject::connect(m_buttonBox, SIGNAL(accepted()), this, SLOT(slotOk()));
QObject::connect(m_buttonBox, SIGNAL(rejected()), this, SLOT(close()));
QObject::connect(m_newRangeButton, SIGNAL(clicked()), this, SLOT(addNewRange()));
QObject::connect(m_deleteRangeButton, SIGNAL(clicked()), this, SLOT(deleteCurrentRange()));
//restore defaults!
QPushButton* defaultsButton = m_buttonBox->button(QDialogButtonBox::RestoreDefaults);
QObject::connect(defaultsButton, SIGNAL(clicked()), this, SLOT(slotDefault()));
}
void FllImporter::processOutputVariable(const std::string& block, Engine* engine) const {
std::istringstream reader(block);
std::string line;
FL_unique_ptr<OutputVariable> outputVariable(new OutputVariable);
while (std::getline(reader, line)) {
std::pair<std::string, std::string> keyValue = parseKeyValue(line, ':');
if ("OutputVariable" == keyValue.first) {
outputVariable->setName(Op::validName(keyValue.second));
} else if ("enabled" == keyValue.first) {
outputVariable->setEnabled(parseBoolean(keyValue.second));
} else if ("range" == keyValue.first) {
std::pair<scalar, scalar> range = parseRange(keyValue.second);
outputVariable->setRange(range.first, range.second);
} else if ("default" == keyValue.first) {
outputVariable->setDefaultValue(Op::toScalar(keyValue.second));
} else if ("lock-previous" == keyValue.first or "lock-valid" == keyValue.first) {
outputVariable->setLockPreviousValue(parseBoolean(keyValue.second));
} else if ("lock-range" == keyValue.first) {
outputVariable->setLockValueInRange(parseBoolean(keyValue.second));
} else if ("defuzzifier" == keyValue.first) {
outputVariable->setDefuzzifier(parseDefuzzifier(keyValue.second));
} else if ("aggregation" == keyValue.first) {
outputVariable->fuzzyOutput()->setAggregation(parseSNorm(keyValue.second));
} else if ("accumulation" == keyValue.first) {
outputVariable->fuzzyOutput()->setAggregation(parseSNorm(keyValue.second));
FL_LOG("[warning] obsolete usage of identifier <accumulation: SNorm> in OutputVariable");
FL_LOG("[information] from version 6.0, the identifier <aggregation: SNorm> should be used");
FL_LOG("[backward compatibility] assumed "
"<aggregation: " << keyValue.second << "> "
"instead of <accumulation: " << keyValue.second << ">");
} else if ("term" == keyValue.first) {
outputVariable->addTerm(parseTerm(keyValue.second, engine));
} else {
throw Exception("[import error] key <" + keyValue.first + "> not "
"recognized in pair <" + keyValue.first + ":" + keyValue.second + ">", FL_AT);
}
}
engine->addOutputVariable(outputVariable.release());
}
void BlobResourceHandle::doStart()
{
ASSERT(isMainThread());
// Do not continue if the request is aborted or an error occurs.
if (m_aborted || m_errorCode)
return;
if (!equalLettersIgnoringASCIICase(firstRequest().httpMethod(), "get")) {
notifyFail(methodNotAllowed);
return;
}
// If the blob data is not found, fail now.
if (!m_blobData) {
m_errorCode = notFoundError;
notifyResponse();
return;
}
// Parse the "Range" header we care about.
String range = firstRequest().httpHeaderField(HTTPHeaderName::Range);
if (!range.isEmpty() && !parseRange(range, m_rangeOffset, m_rangeEnd, m_rangeSuffixLength)) {
m_errorCode = rangeError;
notifyResponse();
return;
}
if (m_async)
getSizeForNext();
else {
Ref<BlobResourceHandle> protectedThis(*this); // getSizeForNext calls the client
for (size_t i = 0; i < m_blobData->items().size() && !m_aborted && !m_errorCode; ++i)
getSizeForNext();
notifyResponse();
}
}
/*
* Parse the request headers. Return true if the header parsed.
*/
static bool parseHeaders(MaConn *conn, MaPacket *packet)
{
MaHostAddress *address;
MaRequest *req;
MaHost *host, *hp;
MaLimits *limits;
MprBuf *content;
char keyBuf[MPR_MAX_STRING];
char *key, *value, *cp, *tok;
int count, keepAlive;
req = conn->request;
host = req->host;
content = packet->content;
conn->request->headerPacket = packet;
limits = &conn->http->limits;
keepAlive = 0;
strcpy(keyBuf, "HTTP_");
mprAssert(strstr((char*) content->start, "\r\n"));
for (count = 0; content->start[0] != '\r' && !conn->connectionFailed; count++) {
if (count >= limits->maxNumHeaders) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Too many headers");
return 0;
}
if ((key = getToken(conn, ":")) == 0 || *key == '\0') {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad header format");
return 0;
}
value = getToken(conn, "\r\n");
while (isspace((int) *value)) {
value++;
}
if (conn->requestFailed) {
continue;
}
mprStrUpper(key);
for (cp = key; *cp; cp++) {
if (*cp == '-') {
*cp = '_';
}
}
mprLog(req, 8, "Key %s, value %s", key, value);
if (strspn(key, "%<>/\\") > 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad header key value");
continue;
}
/*
* Define the header with a "HTTP_" prefix
*/
mprStrcpy(&keyBuf[5], sizeof(keyBuf) - 5, key);
mprAddDuplicateHash(req->headers, keyBuf, value);
switch (key[0]) {
case 'A':
if (strcmp(key, "AUTHORIZATION") == 0) {
value = mprStrdup(req, value);
req->authType = mprStrTok(value, " \t", &tok);
req->authDetails = tok;
} else if (strcmp(key, "ACCEPT_CHARSET") == 0) {
req->acceptCharset = value;
} else if (strcmp(key, "ACCEPT") == 0) {
req->accept = value;
} else if (strcmp(key, "ACCEPT_ENCODING") == 0) {
req->acceptEncoding = value;
}
break;
case 'C':
if (strcmp(key, "CONTENT_LENGTH") == 0) {
if (req->length >= 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Mulitple content length headers");
continue;
}
req->length = mprAtoi(value, 10);
if (req->length < 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad content length");
continue;
}
if (req->length >= host->limits->maxBody) {
maFailConnection(conn, MPR_HTTP_CODE_REQUEST_TOO_LARGE,
"Request content length %Ld is too big. Limit %Ld", req->length, host->limits->maxBody);
continue;
}
mprAssert(req->length >= 0);
req->remainingContent = req->length;
req->contentLengthStr = value;
} else if (strcmp(key, "CONTENT_RANGE") == 0) {
/*
* This headers specifies the range of any posted body data
* Format is: Content-Range: bytes n1-n2/length
* Where n1 is first byte pos and n2 is last byte pos
*/
char *sp;
int start, end, size;
start = end = size = -1;
sp = value;
while (*sp && !isdigit((int) *sp)) {
sp++;
}
if (*sp) {
start = (int) mprAtoi(sp, 10);
if ((sp = strchr(sp, '-')) != 0) {
end = (int) mprAtoi(++sp, 10);
}
if ((sp = strchr(sp, '/')) != 0) {
/*
* Note this is not the content length transmitted, but the original size of the input of which
* the client is transmitting only a portion.
*/
size = (int) mprAtoi(++sp, 10);
}
}
if (start < 0 || end < 0 || size < 0 || end <= start) {
maFailRequest(conn, MPR_HTTP_CODE_RANGE_NOT_SATISFIABLE, "Bad content range");
continue;
}
req->inputRange = maCreateRange(conn, start, end);
} else if (strcmp(key, "CONTENT_TYPE") == 0) {
req->mimeType = value;
req->form = strstr(value, "application/x-www-form-urlencoded") != 0;
} else if (strcmp(key, "COOKIE") == 0) {
if (req->cookie && *req->cookie) {
req->cookie = mprStrcat(req, -1, req->cookie, "; ", value, NULL);
} else {
req->cookie = value;
}
} else if (strcmp(key, "CONNECTION") == 0) {
req->connection = value;
if (mprStrcmpAnyCase(value, "KEEP-ALIVE") == 0) {
keepAlive++;
} else if (mprStrcmpAnyCase(value, "CLOSE") == 0) {
conn->keepAliveCount = 0;
}
if (!host->keepAlive) {
conn->keepAliveCount = 0;
}
}
break;
case 'F':
req->forwarded = value;
break;
case 'H':
if (strcmp(key, "HOST") == 0) {
req->hostName = value;
address = conn->address;
if (maIsNamedVirtualHostAddress(address)) {
hp = maLookupVirtualHost(address, value);
if (hp == 0) {
maFailRequest(conn, 404, "No host to serve request. Searching for %s", value);
mprLog(conn, 1, "Can't find virtual host %s", value);
continue;
}
req->host = hp;
/*
* Reassign this request to a new host
*/
maRemoveConn(host, conn);
host = hp;
conn->host = hp;
maAddConn(hp, conn);
}
}
break;
case 'I':
if ((strcmp(key, "IF_MODIFIED_SINCE") == 0) || (strcmp(key, "IF_UNMODIFIED_SINCE") == 0)) {
MprTime newDate = 0;
char *cp;
bool ifModified = (key[3] == 'M');
if ((cp = strchr(value, ';')) != 0) {
*cp = '\0';
}
if (mprParseTime(conn, &newDate, value, MPR_UTC_TIMEZONE, NULL) < 0) {
mprAssert(0);
break;
}
if (newDate) {
setIfModifiedDate(conn, newDate, ifModified);
req->flags |= MA_REQ_IF_MODIFIED;
}
} else if ((strcmp(key, "IF_MATCH") == 0) || (strcmp(key, "IF_NONE_MATCH") == 0)) {
char *word, *tok;
bool ifMatch = key[3] == 'M';
if ((tok = strchr(value, ';')) != 0) {
*tok = '\0';
}
req->ifMatch = ifMatch;
req->flags |= MA_REQ_IF_MODIFIED;
value = mprStrdup(conn, value);
word = mprStrTok(value, " ,", &tok);
while (word) {
addMatchEtag(conn, word);
word = mprStrTok(0, " ,", &tok);
}
} else if (strcmp(key, "IF_RANGE") == 0) {
char *word, *tok;
if ((tok = strchr(value, ';')) != 0) {
*tok = '\0';
}
req->ifMatch = 1;
req->flags |= MA_REQ_IF_MODIFIED;
value = mprStrdup(conn, value);
word = mprStrTok(value, " ,", &tok);
while (word) {
addMatchEtag(conn, word);
word = mprStrTok(0, " ,", &tok);
}
}
break;
case 'P':
if (strcmp(key, "PRAGMA") == 0) {
req->pragma = value;
}
break;
case 'R':
if (strcmp(key, "RANGE") == 0) {
if (!parseRange(conn, value)) {
maFailRequest(conn, MPR_HTTP_CODE_RANGE_NOT_SATISFIABLE, "Bad range");
}
} else if (strcmp(key, "REFERER") == 0) {
/* NOTE: yes the header is misspelt in the spec */
req->referer = value;
}
break;
case 'T':
if (strcmp(key, "TRANSFER_ENCODING") == 0) {
mprStrLower(value);
if (strcmp(value, "chunked") == 0) {
req->flags |= MA_REQ_CHUNKED;
/*
* This will be revised by the chunk filter as chunks are processed and will be set to zero when the
* last chunk has been received.
*/
req->remainingContent = MAXINT;
}
}
break;
#if BLD_DEBUG
case 'X':
if (strcmp(key, "X_APPWEB_CHUNK_SIZE") == 0) {
mprStrUpper(value);
conn->response->chunkSize = atoi(value);
if (conn->response->chunkSize <= 0) {
conn->response->chunkSize = 0;
} else if (conn->response->chunkSize > conn->http->limits.maxChunkSize) {
conn->response->chunkSize = conn->http->limits.maxChunkSize;
}
}
break;
#endif
case 'U':
if (strcmp(key, "USER_AGENT") == 0) {
req->userAgent = value;
}
break;
}
}
if (conn->protocol == 0 && !keepAlive) {
conn->keepAliveCount = 0;
}
if (!(req->flags & MA_REQ_CHUNKED)) {
/*
* Step over "\r\n" after headers. As an optimization, don't do this if chunked so chunking can parse a single
* chunk delimiter of "\r\nSIZE ...\r\n"
*/
mprAdjustBufStart(content, 2);
}
mprLog(conn, 3, "Select host \"%s\"", conn->host->name);
if (maSetRequestUri(conn, req->url, "") < 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad URI format");
return 0;
}
if (conn->host->secure) {
req->parsedUri->scheme = mprStrdup(req, "https");
}
req->parsedUri->port = conn->sock->port;
req->parsedUri->host = req->hostName ? req->hostName : conn->host->name;
return 1;
}
void ExcelFile::readSheet(Sheet& sh)
{
rapidxml::xml_document<> doc;
rapidxml::xml_node<> *root, *row, *c, *v, *d;
_zip->openXML(sh._path.c_str(), doc);
root = doc.first_node("worksheet");
d = root->first_node("dimension");
if (d)
parseRange(d->first_attribute("ref")->value(), sh._dimension);
row = root->first_node("sheetData");
row = row->first_node("row");
int vecsize = (sh._dimension.lastCol - sh._dimension.firstCol + 1) * (sh._dimension.lastRow - sh._dimension.firstRow + 1);
sh._cells.resize(vecsize);
while (row)
{
int rowIdx = lexical_cast<int>(row->first_attribute("r")->value());
c = row->first_node("c");
while (c)
{
int colIdx = 0;
parseCell(c->first_attribute("r")->value(), rowIdx, colIdx);
int index = sh.toIndex(rowIdx, colIdx);
const char *s, *t;
v = c->first_node("v");
Cell* cell = new Cell;
if (v)
{
s = v->value();
if (c->first_attribute("t"))
{
t = c->first_attribute("t")->value();
if (!strcmp(t, "s"))
{
cell->value = (char*)_sharedString[atoi(s)].c_str();
cell->type = "string";
}
else if (!strcmp(t, "b"))
{
if (!strcmp(s, "0"))
{
cell->value = "FALSE";
}
else
{
cell->value = "TRUE";
}
cell->type = "bool";
}
}
else
{
cell->type = "unknow";
cell->value = (char*)s;
}
}
sh._cells[index] = cell;
c = c->next_sibling("c");
}
row = row->next_sibling("row");
}
}
seqan::ArgumentParser::ParseResult
parseArgs(SakOptions & options,
int argc,
char ** argv)
{
seqan::ArgumentParser parser("sak");
setShortDescription(parser, "Slicing and dicing of FASTA/FASTQ files..");
setVersion(parser, SEQAN_APP_VERSION " [" SEQAN_REVISION "]");
setDate(parser, SEQAN_DATE);
setCategory(parser, "Utilities");
addUsageLine(parser, "[\\fIOPTIONS\\fP] [\\fB-o\\fP \\fIOUT.{fa,fq}\\fP] \\fIIN.{fa,fq}\\fP");
addDescription(parser, "\"It slices, it dices and it makes the laundry!\"");
addDescription(parser, "Original SAK tool by David Weese. Rewrite by Manuel Holtgrewe.");
// The only argument is the input file.
addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::INPUT_FILE, "IN"));
// Only FASTA and FASTQ files are allowed as input.
setValidValues(parser, 0, seqan::SeqFileIn::getFileExtensions());
// TODO(holtgrew): I want a custom help text!
// addOption(parser, seqan::ArgParseOption("h", "help", "This helpful screen."));
addOption(parser, seqan::ArgParseOption("v", "verbose", "Verbose, log to STDERR."));
hideOption(parser, "verbose");
addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Very verbose, log to STDERR."));
hideOption(parser, "very-verbose");
addSection(parser, "Output Options");
addOption(parser, seqan::ArgParseOption("o", "out-path",
"Path to the resulting file. If omitted, result is printed to stdout in FastQ format.",
seqan::ArgParseOption::OUTPUT_FILE, "FASTX"));
setValidValues(parser, "out-path", seqan::SeqFileOut::getFileExtensions());
addOption(parser, seqan::ArgParseOption("rc", "revcomp", "Reverse-complement output."));
addOption(parser, seqan::ArgParseOption("l", "max-length", "Maximal number of sequence characters to write out.",
seqan::ArgParseOption::INTEGER, "LEN"));
addSection(parser, "Filter Options");
addOption(parser, seqan::ArgParseOption("s", "sequence", "Select the given sequence for extraction by 0-based index.",
seqan::ArgParseOption::INTEGER, "NUM", true));
addOption(parser, seqan::ArgParseOption("sn", "sequence-name", "Select sequence with name prefix being \\fINAME\\fP.",
seqan::ArgParseOption::STRING, "NAME", true));
addOption(parser, seqan::ArgParseOption("ss", "sequences",
"Select sequences \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP "
"are 0-based indices.",
seqan::ArgParseArgument::STRING, "RANGE", true));
addOption(parser, seqan::ArgParseOption("i", "infix",
"Select characters \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP "
"are 0-based indices.",
seqan::ArgParseArgument::STRING, "RANGE", true));
addOption(parser, seqan::ArgParseOption("ll", "line-length",
"Set line length in output file. See section \\fILine Length\\fP for details.",
seqan::ArgParseArgument::INTEGER, "LEN", false));
setMinValue(parser, "line-length", "-1");
addTextSection(parser, "Line Length");
addText(parser,
"You can use the setting \\fB--line-length\\fP for setting the resulting line length. By default, "
"sequences in FASTA files are written with at most 70 characters per line and sequences in FASTQ files are "
"written without any line breaks. The quality sequence in FASTQ file is written in the same way as the "
"residue sequence.");
addText(parser,
"The default is selected with a \\fB--line-length\\fP value of \\fI-1\\fP and line breaks can be disabled "
"with a value of \\fI0\\fP.");
addTextSection(parser, "Usage Examples");
addListItem(parser, "\\fBsak\\fP \\fB-s\\fP \\fI10\\fP \\fIIN.fa\\fP",
"Cut out 11th sequence from \\fIIN.fa\\fP and write to stdout as FASTA.");
addListItem(parser, "\\fBsak\\fP \\fB-ss\\fP \\fI10-12\\fP \\fB-ss\\fP \\fI100-200\\fP \\fIIN.fq\\fP",
"Cut out 11th up to and including 12th and 101th up to and including 199th sequence from \\fIIN.fq\\fP "
"and write to stdout as FASTA.");
seqan::ArgumentParser::ParseResult res = parse(parser, argc, argv);
if (res != seqan::ArgumentParser::PARSE_OK)
return res;
getArgumentValue(options.inFastxPath, parser, 0);
seqan::CharString tmp;
getOptionValue(tmp, parser, "out-path");
if (isSet(parser, "out-path"))
getOptionValue(options.outPath, parser, "out-path");
if (isSet(parser, "verbose"))
options.verbosity = 2;
if (isSet(parser, "very-verbose"))
options.verbosity = 3;
if (isSet(parser, "sequence"))
{
std::vector<std::string> sequenceIds = getOptionValues(parser, "sequence");
for (unsigned i = 0; i < seqan::length(sequenceIds); ++i)
{
unsigned idx = 0;
if (!seqan::lexicalCast(idx, sequenceIds[i]))
{
std::cerr << "ERROR: Invalid sequence index " << sequenceIds[i] << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
appendValue(options.seqIndices, idx);
}
}
if (isSet(parser, "sequences"))
{
std::vector<std::string> sequenceRanges = getOptionValues(parser, "sequences");
seqan::CharString buffer;
for (unsigned i = 0; i < seqan::length(sequenceRanges); ++i)
{
seqan::Pair<uint64_t> range;
if (!parseRange(range.i1, range.i2, sequenceRanges[i]))
{
std::cerr << "ERROR: Invalid range " << sequenceRanges[i] << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
appendValue(options.seqIndexRanges, range);
}
}
if (isSet(parser, "infix"))
{
seqan::CharString buffer;
getOptionValue(buffer, parser, "infix");
if (!parseRange(options.seqInfixBegin, options.seqInfixEnd, buffer))
{
std::cerr << "ERROR: Invalid range " << buffer << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
}
options.reverseComplement = isSet(parser, "revcomp");
if (isSet(parser, "max-length"))
getOptionValue(options.maxLength, parser, "max-length");
if (isSet(parser, "sequence-name"))
getOptionValue(options.readPattern, parser, "sequence-name");
getOptionValue(options.seqOutOptions.lineLength, parser, "line-length");
return res;
}
