bool
TeSQLite::generateLabelPositions(TeTheme *theme, const std::string& objectId)
{
string geomTable, upd;
string collTable = theme->collectionTable();
if((collTable.empty()) || (!tableExist(collTable)))
return false;
if( theme->layer()->hasGeometry(TeCELLS) )
{
geomTable = theme->layer()->tableName(TeCELLS);
upd= "UPDATE " + collTable + " SET ";
upd += " label_x = (SELECT MAX(lower_x + (upper_x - lower_x)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id), ";
upd += " label_y = (SELECT MAX(lower_y + (upper_y - lower_y)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id) ";
upd += " WHERE label_x IS NULL OR label_y IS NULL";
}
if( theme->layer()->hasGeometry(TePOLYGONS) )
{
geomTable = theme->layer()->tableName(TePOLYGONS);
upd= "UPDATE " + collTable + " SET ";
upd += " label_x = (SELECT MAX(lower_x + (upper_x - lower_x)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id), ";
upd += " label_y = (SELECT MAX(lower_y + (upper_y - lower_y)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id) ";
upd += " WHERE label_x IS NULL OR label_y IS NULL";
}
if( theme->layer()->hasGeometry(TeLINES) )
{
geomTable = theme->layer()->tableName(TeLINES);
upd= "UPDATE " + collTable + " SET ";
upd += " label_x = (SELECT MAX(lower_x + (upper_x - lower_x)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id), ";
upd += " label_y = (SELECT MAX(lower_y + (upper_y - lower_y)/2) ";
upd += "FROM " + geomTable + " WHERE object_id = c_object_id) ";
upd += " WHERE label_x IS NULL OR label_y IS NULL";
}
if(theme->layer()->hasGeometry(TePOINTS))
{
geomTable = theme->layer()->tableName(TePOINTS);
upd= " UPDATE " + collTable + " SET ";
upd += " label_x = (SELECT MAX(x) ";
upd += " FROM " + geomTable + " p WHERE object_id = c_object_id), ";
upd += " label_y = (SELECT MAX(y) ";
upd += " FROM " + geomTable + " p WHERE object_id = c_object_id) ";
upd += " WHERE label_x IS NULL OR label_y IS NULL";
}
if (!upd.empty())
{
if (!objectId.empty())
{
upd += " AND c_object_id='"+objectId+"'";
}
if(!execute(upd))
return false;
}
return true;
}
bool ParseDouble(const std::string& string, double& value)
{
return swri_string_util::ToDouble(string, value) || string.empty();
}
bool ParseUInt32(const std::string& string, uint32_t& value, int32_t base)
{
return swri_string_util::ToUInt32(string, value, base) || string.empty();
}
bool Parser::parseLine(std::string &ErrStr) {
switch (CurTok.K) {
case Token::Ident:
if (CurTok.str() == "cand") {
if (RK == ReplacementKind::ParseLHS) {
ErrStr = makeErrStr("Not expecting 'cand' when parsing LHS");
return false;
}
if (RK == ReplacementKind::ParseRHS) {
ErrStr = makeErrStr("Not expecting 'cand' when parsing RHS");
return false;
}
if (!consumeToken(ErrStr)) return false;
InstMapping Cand = parseInstMapping(ErrStr);
if (!ErrStr.empty()) return false;
Reps.push_back(ParsedReplacement{Cand, std::move(PCs),
std::move(BPCs)});
nextReplacement();
return true;
} else if (CurTok.str() == "infer") {
if (RK == ReplacementKind::ParseRHS) {
ErrStr = makeErrStr("Not expecting 'infer' when parsing RHS");
return false;
}
if (!consumeToken(ErrStr)) return false;
if (LHS) {
ErrStr = makeErrStr("Not expecting a second 'infer'");
return false;
}
LHS = parseInst(ErrStr);
if (!LHS)
return false;
if (RK == ReplacementKind::ParseLHS) {
Reps.push_back(ParsedReplacement{InstMapping(LHS, 0),
std::move(PCs), std::move(BPCs)});
nextReplacement();
}
return true;
} else if (CurTok.str() == "result") {
if (RK == ReplacementKind::ParseLHS) {
ErrStr = makeErrStr("Not expecting 'result' when parsing LHS");
return false;
}
if (RK != ReplacementKind::ParseRHS && !LHS) {
ErrStr = makeErrStr("Not expecting 'result' before 'infer'");
return false;
}
if (!consumeToken(ErrStr)) return false;
Inst *RHS = parseInst(ErrStr);
if (!RHS)
return false;
InstMapping Cand = InstMapping(LHS, RHS);
Reps.push_back(ParsedReplacement{Cand, std::move(PCs),
std::move(BPCs)});
nextReplacement();
return true;
} else if (CurTok.str() == "pc") {
if (!consumeToken(ErrStr)) return false;
InstMapping PC = parseInstMapping(ErrStr);
if (!ErrStr.empty()) return false;
PCs.push_back(PC);
return true;
} else if (CurTok.str() == "blockpc") {
if (!consumeToken(ErrStr)) return false;
if (CurTok.K != Token::ValName) {
ErrStr = makeErrStr("expected block var");
return false;
}
StringRef InstName = CurTok.Name;
unsigned InstWidth = CurTok.Width;
if (InstWidth != 0) {
ErrStr = makeErrStr("blocks may not have a width");
return false;
}
if (Context.getInst(CurTok.Name)) {
ErrStr = makeErrStr(std::string("%") + InstName.str() +
" is declared as an inst");
return false;
}
Block *B = Context.getBlock(InstName);
if (B == 0) {
ErrStr = makeErrStr(std::string("block %") + InstName.str() +
" is undeclared");
return false;
}
if (!consumeToken(ErrStr)) return false;
if (CurTok.K != Token::UntypedInt) {
ErrStr = makeErrStr(std::string("expected block number"));
return false;
}
unsigned CurrIdx = CurTok.Val.getLimitedValue();
if (!consumeToken(ErrStr)) return false;
InstMapping PC = parseInstMapping(ErrStr);
if (!ErrStr.empty()) return false;
std::map<Block *, unsigned>::iterator IdxIt = BlockPCIdxMap.find(B);
if (IdxIt == BlockPCIdxMap.end()) {
BlockPCIdxMap[B] = CurrIdx;
}
else {
assert(BPCs.size() && "Empty BlockPCs!");
if (CurrIdx > IdxIt->second)
BlockPCIdxMap[B] = CurrIdx;
}
BPCs.emplace_back(B, CurrIdx, PC);
return true;
} else {
ErrStr = makeErrStr(std::string("unexpected identifier: '") +
CurTok.str().str() + "'");
return false;
}
case Token::ValName: {
StringRef InstName = CurTok.Name;
unsigned InstWidth = CurTok.Width;
if (Context.getInst(InstName)) {
ErrStr = makeErrStr(std::string("%") + InstName.str() +
" already declared as an inst");
return false;
}
if (Context.getBlock(InstName)) {
ErrStr = makeErrStr(std::string("%") + InstName.str() +
" already declared as a block");
return false;
}
TokenPos TP = L.getTokenPos(CurTok);
if (!consumeToken(ErrStr)) return false;
if (CurTok.K != Token::Eq) {
ErrStr = makeErrStr("expected '='");
return false;
}
if (!consumeToken(ErrStr)) return false;
if (CurTok.K != Token::Ident) {
ErrStr = makeErrStr("expected identifier");
return false;
}
Inst::Kind IK = Inst::getKind(CurTok.str());
if (IK == Inst::BSwap) {
if (InstWidth != 16 && InstWidth != 32 && InstWidth != 64) {
ErrStr = makeErrStr(TP, CurTok.str().str() + " doesn't support " +
std::to_string(InstWidth) + " bits");
return false;
}
}
if ((IK == Inst::CtPop) || (IK == Inst::Ctlz) || (IK == Inst::Cttz)) {
if (InstWidth !=8 && InstWidth != 16 && InstWidth != 32 &&
InstWidth != 64 && InstWidth != 256) {
ErrStr = makeErrStr(TP, CurTok.str().str() + " doesn't support " +
std::to_string(InstWidth) + " bits");
return false;
}
}
if (IK == Inst::Kind(~0)) {
if (CurTok.str() == "block") {
if (InstWidth != 0) {
ErrStr = makeErrStr(TP, "blocks may not have a width");
return false;
}
if (!consumeToken(ErrStr))
return false;
if (CurTok.K != Token::UntypedInt) {
ErrStr = makeErrStr(TP, "block must be followed by number of preds");
return false;
}
unsigned Preds = CurTok.Val.getLimitedValue();
Context.setBlock(InstName, IC.createBlock(Preds));
return consumeToken(ErrStr);
} else {
ErrStr = makeErrStr(std::string("unexpected inst kind: '") +
CurTok.str().str() + "'");
return false;
}
}
if (IK == Inst::Var && InstWidth == 0) {
ErrStr = makeErrStr(TP, "var must have a width");
return false;
}
if (!consumeToken(ErrStr)) return false;
Block *B = 0;
if (IK == Inst::Var) {
llvm::APInt Zero(InstWidth, 0, false), One(InstWidth, 0, false),
ConstOne(InstWidth, 1, false);
bool NonZero = false, NonNegative = false, PowOfTwo = false;
unsigned SignBits = 0;
while (CurTok.K != Token::ValName && CurTok.K != Token::Ident && CurTok.K != Token::Eof) {
if (CurTok.K == Token::KnownBits) {
if (InstWidth != CurTok.PatternString.length()) {
ErrStr = makeErrStr(TP, "knownbits pattern must be of same length as var width");
return false;
}
for (unsigned i=0; i<InstWidth; ++i) {
if (CurTok.PatternString[i] == '0')
Zero += ConstOne.shl(CurTok.PatternString.length()-1-i);
else if (CurTok.PatternString[i] == '1')
One += ConstOne.shl(CurTok.PatternString.length()-1-i);
}
if (!consumeToken(ErrStr))
return false;
}
if (CurTok.K == Token::MoreKnownBits) {
for (unsigned i=0; i<CurTok.PatternString.length(); ++i) {
if (CurTok.PatternString[i] == 'z') {
if (NonZero) {
ErrStr = makeErrStr(TP, "repeated 'z' flag");
return false;
}
NonZero = true;
} else if (CurTok.PatternString[i] == 'n') {
if (NonNegative) {
ErrStr = makeErrStr(TP, "repeated 'n' flag");
return false;
}
NonNegative = true;
} else if (CurTok.PatternString[i] == 'p') {
if (PowOfTwo) {
ErrStr = makeErrStr(TP, "repeated 'p' flag");
return false;
}
PowOfTwo = true;
} else {
llvm_unreachable("nzp should have been checked earlier");
}
}
if (!consumeToken(ErrStr))
return false;
}
}
Inst *I = IC.createVar(InstWidth, InstName, Zero, One, NonZero, NonNegative, PowOfTwo);
Context.setInst(InstName, I);
return true;
}
if (IK == Inst::Phi) {
if (CurTok.K != Token::ValName) {
ErrStr = makeErrStr("expected block number");
return false;
}
if (CurTok.Width != 0) {
ErrStr = makeErrStr("blocks may not have a width");
return false;
}
if (!(B = Context.getBlock(CurTok.Name))) {
ErrStr =
makeErrStr(std::string("%") + InstName.str() + " is not a block");
return false;
}
if (!consumeToken(ErrStr)) return false;
if (CurTok.K != Token::Comma) {
ErrStr = makeErrStr("expected ','");
return false;
}
if (!consumeToken(ErrStr)) return false;
}
std::vector<Inst *> Ops;
while (1) {
Inst *I = parseInst(ErrStr);
if (!I)
return false;
Ops.push_back(I);
if (CurTok.K != Token::Comma) break;
if (!consumeToken(ErrStr)) return false;
}
Inst *I;
if (IK == Inst::Phi) {
assert(B);
if (!typeCheckPhi(InstWidth, B, Ops, ErrStr)) {
ErrStr = makeErrStr(TP, ErrStr);
return false;
}
I = IC.getPhi(B, Ops);
} else {
if (!typeCheckInst(IK, InstWidth, Ops, ErrStr)) {
ErrStr = makeErrStr(TP, ErrStr);
return false;
}
switch (IK) {
case Inst::SAddWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Add, Ops[0]->Width, Ops),
IC.getInst(Inst::SAddO, 1, Ops)
});
break;
case Inst::UAddWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Add, Ops[0]->Width, Ops),
IC.getInst(Inst::UAddO, 1, Ops)
});
break;
case Inst::SSubWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Sub, Ops[0]->Width, Ops),
IC.getInst(Inst::SSubO, 1, Ops)
});
break;
case Inst::USubWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Sub, Ops[0]->Width, Ops),
IC.getInst(Inst::USubO, 1, Ops)
});
break;
case Inst::SMulWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Mul, Ops[0]->Width, Ops),
IC.getInst(Inst::SMulO, 1, Ops)
});
break;
case Inst::UMulWithOverflow:
I = IC.getInst(IK, InstWidth, {IC.getInst(Inst::Mul, Ops[0]->Width, Ops),
IC.getInst(Inst::UMulO, 1, Ops)
});
break;
default:
I = IC.getInst(IK, InstWidth, Ops);
break;
}
}
Context.setInst(InstName, I);
return true;
}
default:
ErrStr =
makeErrStr("expected inst, block, cand, infer, result, pc, or blockpc");
return false;
}
}
void file_server::main(std::string file_name)
{
std::string path;
if(!check_in_document_root(file_name,path)) {
show404();
return;
}
int s=file_mode(path);
if((s & S_IFDIR)) {
std::string path2;
int mode_2=0;
bool have_index = check_in_document_root(file_name+"/" + index_file_ ,path2);
if(have_index) {
mode_2 = file_mode(path2);
have_index = (mode_2 & S_IFREG) != 0;
}
if( !file_name.empty()
&& file_name[file_name.size()-1]!='/' // not ending with "/" as should
&& (have_index || list_directories_)
)
{
response().set_redirect_header(file_name + "/");
response().out()<<std::flush;
return;
}
if(have_index) {
path = path2;
s=mode_2;
}
else {
if(list_directories_)
list_dir(file_name,path);
else
show404();
return;
}
}
if(!(s & S_IFREG)) {
show404();
return;
}
std::string ext;
size_t pos = path.rfind('.');
if(pos != std::string::npos)
ext=path.substr(pos);
mime_type::const_iterator p=mime_.find(ext);
if(p!=mime_.end())
response().content_type(p->second);
else
response().content_type("application/octet-stream");
if(!allow_deflate_) {
response().io_mode(http::response::nogzip);
}
booster::nowide::ifstream file(path.c_str(),std::ios_base::binary);
if(!file) {
show404();
return;
}
response().out()<<file.rdbuf(); // write stream to stream
}
bool hasLookupURL()
{
return !sLookupURL.empty();
}
void addCustomFunctionSource(const std::string& filename, const std::string& source) {
CPPADCG_ASSERT_KNOWN(!filename.empty(), "The filename name cannot be empty");
_customSource[filename] = source;
}
void FUGNetzteil::setError(std::string command, std::string error)
{
if (error=="E0") return;
lastError ="";
lastError += boost::posix_time::to_iso_extended_string(boost::posix_time::second_clock::local_time());
lastError +=" ";
lastError += command;
lastError += " ; ";
error.erase( std::remove(error.begin(), error.end(), '\n'), error.end() );
lastError += error;
lastError += ": ";
std::string discription;
int errorNum;
error.erase( std::remove(error.begin(), error.end(), 'E'), error.end() );
if(!error.empty())
errorNum = std::stoi (error);
else
errorNum = -1;
if (errorNum == 1)
{
discription="keine Daten verfügbar";
}
else if (errorNum == 2)
{
discription="unbekannter Register-Typ";
}
else if (errorNum == 4)
{
discription="ungültiges Argument";
}
else if (errorNum == 5)
{
discription="Bereich überschritten";
}
else if (errorNum == 6)
{
discription="Register darf nur gelesen werden";
}
else if (errorNum == 7)
{
discription="Receive Overflow";
}
else if (errorNum ==8 )
{
discription="EEPROM ist schreibgeschützt";
}
else if (errorNum == 9)
{
discription="Adressfehler";
}
else if (errorNum ==10 )
{
discription="unbekannter SCPI Befehl";
}
else if (errorNum ==11 )
{
discription="Trigger on Talk Fehler";
}
else if (errorNum ==12 )
{
discription="~Tn Befehl hatte ungültiges Argument";
}
else if (errorNum ==13 )
{
discription="ungültiger N-Wert";
}
else if (errorNum == 14)
{
discription="Register darf nurbeschrieben werden";
}
else if (errorNum == 15)
{
discription="String zu lang";
}
else if (errorNum == 101||errorNum == 102||errorNum == 103)
{
discription="Checksumme falsch";
}
else
{
discription="unbekannter Fehler";
}
lastError += discription;
return;
}
void
XMLSocket_as::checkForIncomingData()
{
assert(ready());
std::vector<std::string> msgs;
const int bufSize = 10000;
boost::scoped_array<char> buf(new char[bufSize]);
const size_t bytesRead = _socket.readNonBlocking(buf.get(), bufSize - 1);
// Return if there's no data.
if (!bytesRead) return;
if (buf[bytesRead - 1] != 0) {
// We received a partial message, so bung
// a null-terminator on the end.
buf[bytesRead] = 0;
}
char* ptr = buf.get();
while (static_cast<size_t>(ptr - buf.get()) < bytesRead) {
#ifdef GNASH_XMLSOCKET_DEBUG
log_debug ("read: %d, this string ends: %d", bytesRead,
ptr + std::strlen(ptr) - buf.get());
#endif
std::string msg(ptr);
// If the string reaches to the final byte read, it's
// incomplete. Store it and continue. The buffer is
// NULL-terminated, so this cannot read past the end.
if (static_cast<size_t>(
ptr + std::strlen(ptr) - buf.get()) == bytesRead) {
_remainder += msg;
break;
}
if (!_remainder.empty()) {
msgs.push_back(_remainder + msg);
ptr += msg.size() + 1;
_remainder.clear();
continue;
}
// Don't do anything if nothing is received.
msgs.push_back(msg);
ptr += msg.size() + 1;
}
if (msgs.empty()) return;
#ifdef GNASH_XMLSOCKET_DEBUG
for (size_t i = 0, e = msgs.size(); i != e; ++i) {
log_debug(_(" Message %d: %s "), i, msgs[i]);
}
#endif
for (XMLSocket_as::MessageList::const_iterator it=msgs.begin(),
itEnd=msgs.end(); it != itEnd; ++it) {
callMethod(&owner(), NSV::PROP_ON_DATA, *it);
}
if (_socket.bad()) {
callMethod(&owner(), NSV::PROP_ON_CLOSE);
close();
return;
}
}
SmartPtrCLogicalRelationshipDoc LogicalRelationshipXml::parse(
const SmartPtrCXmlElement thisXml) {
CAF_CM_STATIC_FUNC_VALIDATE("LogicalRelationshipXml", "parse");
SmartPtrCLogicalRelationshipDoc logicalRelationshipDoc;
CAF_CM_ENTER {
CAF_CM_VALIDATE_SMARTPTR(thisXml);
const std::string namespaceValStrVal =
thisXml->findRequiredAttribute("namespace");
const std::string namespaceValVal = namespaceValStrVal;
const std::string nameStrVal =
thisXml->findRequiredAttribute("name");
const std::string nameVal = nameStrVal;
const std::string versionStrVal =
thisXml->findRequiredAttribute("version");
const std::string versionVal = versionStrVal;
const std::string arityStrVal =
thisXml->findRequiredAttribute("arity");
ARITY_TYPE arityVal = ARITY_NONE;
if (! arityStrVal.empty()) {
arityVal = EnumConvertersXml::convertStringToArityType(arityStrVal);
}
const SmartPtrCXmlElement dataClassLeftXml =
thisXml->findRequiredChild("dataClassLeft");
SmartPtrCClassCardinalityDoc dataClassLeftVal;
if (! dataClassLeftXml.IsNull()) {
dataClassLeftVal = ClassCardinalityXml::parse(dataClassLeftXml);
}
const SmartPtrCXmlElement dataClassRightXml =
thisXml->findRequiredChild("dataClassRight");
SmartPtrCClassCardinalityDoc dataClassRightVal;
if (! dataClassRightXml.IsNull()) {
dataClassRightVal = ClassCardinalityXml::parse(dataClassRightXml);
}
const CXmlElement::SmartPtrCElementCollection joinChildrenXml =
thisXml->findRequiredChildren("join");
std::deque<SmartPtrCJoinTypeDoc> joinVal;
if (! joinChildrenXml.IsNull() && ! joinChildrenXml->empty()) {
for (TConstIterator<CXmlElement::CElementCollection> joinXmlIter(*joinChildrenXml);
joinXmlIter; joinXmlIter++) {
const SmartPtrCXmlElement joinXml = joinXmlIter->second;
const SmartPtrCJoinTypeDoc joinDoc =
JoinTypeXml::parse(joinXml);
joinVal.push_back(joinDoc);
}
}
const std::string descriptionStrVal =
thisXml->findOptionalAttribute("description");
const std::string descriptionVal = descriptionStrVal;
logicalRelationshipDoc.CreateInstance();
logicalRelationshipDoc->initialize(
namespaceValVal,
nameVal,
versionVal,
arityVal,
dataClassLeftVal,
dataClassRightVal,
joinVal,
descriptionVal);
}
CAF_CM_EXIT;
return logicalRelationshipDoc;
}
/* ****************************************************************************
*
* httpRequestSendWithCurl -
*
* The waitForResponse arguments specifies if the method has to wait for response
* before return. If this argument is false, the return string is ""
*
* NOTE
* We are using a hybrid approach, consisting in a static thread-local buffer of a
* small size that copes with most notifications to avoid expensive
* calloc/free syscalls if the notification payload is not very large.
*
* RETURN VALUES
* httpRequestSendWithCurl returns 0 on success and a negative number on failure:
* -1: Invalid port
* -2: Invalid IP
* -3: Invalid verb
* -4: Invalid resource
* -5: No Content-Type BUT content present
* -6: Content-Type present but there is no content
* -7: Total outgoing message size is too big
* -9: Error making HTTP request
*/
int httpRequestSendWithCurl
(
CURL *curl,
const std::string& _ip,
unsigned short port,
const std::string& protocol,
const std::string& verb,
const std::string& tenant,
const std::string& servicePath,
const std::string& xauthToken,
const std::string& resource,
const std::string& orig_content_type,
const std::string& content,
bool useRush,
bool waitForResponse,
std::string* outP,
const std::string& acceptFormat,
long timeoutInMilliseconds
)
{
char portAsString[STRING_SIZE_FOR_INT];
static unsigned long long callNo = 0;
std::string result;
std::string ip = _ip;
struct curl_slist* headers = NULL;
MemoryStruct* httpResponse = NULL;
CURLcode res;
int outgoingMsgSize = 0;
std::string content_type(orig_content_type);
++callNo;
// For content-type application/json we add charset=utf-8
if (orig_content_type == "application/json")
{
content_type += "; charset=utf-8";
}
if (timeoutInMilliseconds == -1)
{
timeoutInMilliseconds = defaultTimeout;
}
lmTransactionStart("to", ip.c_str(), port, resource.c_str());
// Preconditions check
if (port == 0)
{
LM_E(("Runtime Error (port is ZERO)"));
lmTransactionEnd();
*outP = "error";
return -1;
}
if (ip.empty())
{
LM_E(("Runtime Error (ip is empty)"));
lmTransactionEnd();
*outP = "error";
return -2;
}
if (verb.empty())
{
LM_E(("Runtime Error (verb is empty)"));
lmTransactionEnd();
*outP = "error";
return -3;
}
if (resource.empty())
{
LM_E(("Runtime Error (resource is empty)"));
lmTransactionEnd();
*outP = "error";
return -4;
}
if ((content_type.empty()) && (!content.empty()))
{
LM_E(("Runtime Error (Content-Type is empty but there is actual content)"));
lmTransactionEnd();
*outP = "error";
return -5;
}
if ((!content_type.empty()) && (content.empty()))
{
LM_E(("Runtime Error (Content-Type non-empty but there is no content)"));
lmTransactionEnd();
*outP = "error";
return -6;
}
// Allocate to hold HTTP response
httpResponse = new MemoryStruct;
httpResponse->memory = (char*) malloc(1); // will grow as needed
httpResponse->size = 0; // no data at this point
//
// Rush
// Every call to httpRequestSend specifies whether RUSH should be used or not.
// But, this depends also on how the broker was started, so here the 'useRush'
// parameter is cancelled in case the broker was started without rush.
//
// If rush is to be used, the IP/port is stored in rushHeaderIP/rushHeaderPort and
// after that, the host and port of rush is set as ip/port for the message, that is
// now sent to rush instead of to its final destination.
// Also, a few HTTP headers for rush must be setup.
//
if ((rushPort == 0) || (rushHost == ""))
{
useRush = false;
}
if (useRush)
{
char rushHeaderPortAsString[STRING_SIZE_FOR_INT];
uint16_t rushHeaderPort = port;
std::string rushHeaderIP = ip;
std::string headerRushHttp;
ip = rushHost;
port = rushPort;
snprintf(rushHeaderPortAsString, sizeof(rushHeaderPortAsString), "%d", rushHeaderPort);
headerRushHttp = "X-relayer-host: " + rushHeaderIP + ":" + rushHeaderPortAsString;
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerRushHttp.c_str()));
headers = curl_slist_append(headers, headerRushHttp.c_str());
outgoingMsgSize += headerRushHttp.size();
if (protocol == "https:")
{
headerRushHttp = "X-relayer-protocol: https";
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerRushHttp.c_str()));
headers = curl_slist_append(headers, headerRushHttp.c_str());
outgoingMsgSize += headerRushHttp.size();
}
}
snprintf(portAsString, sizeof(portAsString), "%u", port);
// ----- User Agent
char cvBuf[CURL_VERSION_MAX_LENGTH];
char headerUserAgent[HTTP_HEADER_USER_AGENT_MAX_LENGTH];
snprintf(headerUserAgent, sizeof(headerUserAgent), "User-Agent: orion/%s libcurl/%s", versionGet(), curlVersionGet(cvBuf, sizeof(cvBuf)));
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerUserAgent));
headers = curl_slist_append(headers, headerUserAgent);
outgoingMsgSize += strlen(headerUserAgent) + 1;
// ----- Host
char headerHost[HTTP_HEADER_HOST_MAX_LENGTH];
snprintf(headerHost, sizeof(headerHost), "Host: %s:%d", ip.c_str(), (int) port);
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerHost));
headers = curl_slist_append(headers, headerHost);
outgoingMsgSize += strlen(headerHost) + 1;
// ----- Tenant
if (tenant != "")
{
headers = curl_slist_append(headers, ("fiware-service: " + tenant).c_str());
outgoingMsgSize += tenant.size() + 16; // "fiware-service: "
}
// ----- Service-Path
if (servicePath != "")
{
headers = curl_slist_append(headers, ("Fiware-ServicePath: " + servicePath).c_str());
outgoingMsgSize += servicePath.size() + strlen("Fiware-ServicePath: ");
}
// ----- X-Auth-Token
if (xauthToken != "")
{
headers = curl_slist_append(headers, ("X-Auth-Token: " + xauthToken).c_str());
outgoingMsgSize += xauthToken.size() + strlen("X-Auth-Token: ");
}
// ----- Accept
std::string acceptedFormats = "application/xml, application/json";
if (acceptFormat != "")
{
acceptedFormats = acceptFormat;
}
std::string acceptString = "Accept: " + acceptedFormats;
headers = curl_slist_append(headers, acceptString.c_str());
outgoingMsgSize += acceptString.size();
// ----- Expect
headers = curl_slist_append(headers, "Expect: ");
outgoingMsgSize += 8; // from "Expect: "
// ----- Content-length
std::stringstream contentLengthStringStream;
contentLengthStringStream << content.size();
std::string headerContentLength = "Content-length: " + contentLengthStringStream.str();
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerContentLength.c_str()));
headers = curl_slist_append(headers, headerContentLength.c_str());
outgoingMsgSize += contentLengthStringStream.str().size() + 16; // from "Content-length: "
outgoingMsgSize += content.size();
// ----- Content-type
headers = curl_slist_append(headers, ("Content-type: " + content_type).c_str());
outgoingMsgSize += content_type.size() + 14; // from "Content-type: "
// Check if total outgoing message size is too big
if (outgoingMsgSize > MAX_DYN_MSG_SIZE)
{
LM_E(("Runtime Error (HTTP request to send is too large: %d bytes)", outgoingMsgSize));
curl_slist_free_all(headers);
free(httpResponse->memory);
delete httpResponse;
lmTransactionEnd();
*outP = "error";
return -7;
}
// Contents
const char* payload = content.c_str();
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (u_int8_t*) payload);
// Set up URL
std::string url;
if (isIPv6(ip))
url = "[" + ip + "]";
else
url = ip;
url = url + ":" + portAsString + (resource.at(0) == '/'? "" : "/") + resource;
// Prepare CURL handle with obtained options
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb.c_str()); // Set HTTP verb
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Allow redirection (?)
curl_easy_setopt(curl, CURLOPT_HEADER, 1); // Activate include the header in the body output
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); // Put headers in place
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &writeMemoryCallback); // Send data here
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*) httpResponse); // Custom data for response handling
//
// There is a known problem in libcurl (see http://stackoverflow.com/questions/9191668/error-longjmp-causes-uninitialized-stack-frame)
// which is solved using CURLOPT_NOSIGNAL. If we update some day from libcurl 7.19 (the one that comes with CentOS 6.x) to a newer version
// (there are some reports about the bug is no longer in libcurl 7.32), using CURLOPT_NOSIGNAL could be not necessary and this be removed).
// See issue #1016 for more details.
//
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
//
// Timeout
//
// The parameter timeoutInMilliseconds holds the timeout time in milliseconds.
// If the timeout time requested is 0, then no timeuot is used.
//
if (timeoutInMilliseconds != 0)
{
curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeoutInMilliseconds);
}
// Synchronous HTTP request
LM_T(LmtClientOutputPayload, ("Sending message %lu to HTTP server: sending message of %d bytes to HTTP server", callNo, outgoingMsgSize));
res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
//
// NOTE: This log line is used by the functional tests in cases/880_timeout_for_forward_and_notifications/
// So, this line should not be removed/altered, at least not without also modifying the functests.
//
alarmMgr.notificationError(url, "(curl_easy_perform failed: " + std::string(curl_easy_strerror(res)) + ")");
*outP = "notification failure";
}
else
{
// The Response is here
LM_I(("Notification Successfully Sent to %s", url.c_str()));
outP->assign(httpResponse->memory, httpResponse->size);
}
// Cleanup curl environment
curl_slist_free_all(headers);
free(httpResponse->memory);
delete httpResponse;
lmTransactionEnd();
return res == CURLE_OK ? 0 : -9;
}
void LogicalRelationshipXml::add(
const SmartPtrCLogicalRelationshipDoc logicalRelationshipDoc,
const SmartPtrCXmlElement thisXml) {
CAF_CM_STATIC_FUNC_VALIDATE("LogicalRelationshipXml", "add");
CAF_CM_ENTER {
CAF_CM_VALIDATE_SMARTPTR(logicalRelationshipDoc);
CAF_CM_VALIDATE_SMARTPTR(thisXml);
const std::string namespaceValVal = logicalRelationshipDoc->getNamespaceVal();
CAF_CM_VALIDATE_STRING(namespaceValVal);
thisXml->addAttribute("namespace", namespaceValVal);
const std::string nameVal = logicalRelationshipDoc->getName();
CAF_CM_VALIDATE_STRING(nameVal);
thisXml->addAttribute("name", nameVal);
const std::string versionVal = logicalRelationshipDoc->getVersion();
CAF_CM_VALIDATE_STRING(versionVal);
thisXml->addAttribute("version", versionVal);
const std::string arityVal =
EnumConvertersXml::convertArityTypeToString(logicalRelationshipDoc->getArity());
CAF_CM_VALIDATE_STRING(arityVal);
thisXml->addAttribute("arity", arityVal);
const SmartPtrCClassCardinalityDoc dataClassLeftVal =
logicalRelationshipDoc->getDataClassLeft();
CAF_CM_VALIDATE_SMARTPTR(dataClassLeftVal);
const SmartPtrCXmlElement dataClassLeftXml =
thisXml->createAndAddElement("dataClassLeft");
ClassCardinalityXml::add(dataClassLeftVal, dataClassLeftXml);
const SmartPtrCClassCardinalityDoc dataClassRightVal =
logicalRelationshipDoc->getDataClassRight();
CAF_CM_VALIDATE_SMARTPTR(dataClassRightVal);
const SmartPtrCXmlElement dataClassRightXml =
thisXml->createAndAddElement("dataClassRight");
ClassCardinalityXml::add(dataClassRightVal, dataClassRightXml);
const std::deque<SmartPtrCJoinTypeDoc> joinVal =
logicalRelationshipDoc->getJoinCollection();
CAF_CM_VALIDATE_STL(joinVal);
if (! joinVal.empty()) {
for (TConstIterator<std::deque<SmartPtrCJoinTypeDoc> > joinIter(joinVal);
joinIter; joinIter++) {
const SmartPtrCXmlElement joinXml =
thisXml->createAndAddElement("join");
JoinTypeXml::add(*joinIter, joinXml);
}
}
const std::string descriptionVal = logicalRelationshipDoc->getDescription();
if (! descriptionVal.empty()) {
thisXml->addAttribute("description", descriptionVal);
}
}
CAF_CM_EXIT;
}
static bool table_info(std::string & key_field,
bool detected_types,
std::string & field,
std::string & table,
mapnik::layer_descriptor & desc,
boost::shared_ptr<sqlite_connection> ds)
{
// http://www.sqlite.org/pragma.html#pragma_table_info
// use pragma table_info to detect primary key
// and to detect types if no subquery is used or
// if the subquery-based type detection failed
std::ostringstream s;
s << "PRAGMA table_info(" << table << ")";
boost::shared_ptr<sqlite_resultset> rs(ds->execute_query(s.str()));
bool found_table = false;
bool found_pk = false;
while (rs->is_valid() && rs->step_next())
{
found_table = true;
const char* fld_name = rs->column_text(1);
std::string fld_type(rs->column_text(2));
int fld_pk = rs->column_integer(5);
boost::algorithm::to_lower(fld_type);
// TODO - how to handle primary keys on multiple columns ?
if (key_field.empty() && ! found_pk && fld_pk != 0)
{
key_field = fld_name;
found_pk = true;
}
if (! detected_types)
{
// see 2.1 "Column Affinity" at http://www.sqlite.org/datatype3.html
// TODO - refactor this somehow ?
if (field.empty()
&& ((boost::algorithm::contains(fld_type, "geom") ||
boost::algorithm::contains(fld_type, "point") ||
boost::algorithm::contains(fld_type, "linestring") ||
boost::algorithm::contains(fld_type, "polygon"))
||
(boost::algorithm::icontains(fld_name, "geom") ||
boost::algorithm::icontains(fld_name, "point") ||
boost::algorithm::icontains(fld_name, "linestring") ||
boost::algorithm::icontains(fld_name, "polygon")))
)
{
field = std::string(fld_name);
}
else if (boost::algorithm::contains(fld_type, "int"))
{
desc.add_descriptor(mapnik::attribute_descriptor(fld_name, mapnik::Integer));
}
else if (boost::algorithm::contains(fld_type, "text") ||
boost::algorithm::contains(fld_type, "char") ||
boost::algorithm::contains(fld_type, "clob"))
{
desc.add_descriptor(mapnik::attribute_descriptor(fld_name, mapnik::String));
}
else if (boost::algorithm::contains(fld_type, "real") ||
boost::algorithm::contains(fld_type, "float") ||
boost::algorithm::contains(fld_type, "double"))
{
desc.add_descriptor(mapnik::attribute_descriptor(fld_name, mapnik::Double));
}
else if (boost::algorithm::contains(fld_type, "blob"))
{
if (! field.empty())
{
desc.add_descriptor(mapnik::attribute_descriptor(fld_name, mapnik::String));
}
}
#ifdef MAPNIK_DEBUG
else
{
// "Column Affinity" says default to "Numeric" but for now we pass..
//desc_.add_descriptor(attribute_descriptor(fld_name,mapnik::Double));
// TODO - this should not fail when we specify geometry_field in XML file
std::clog << "Sqlite Plugin: column '"
<< std::string(fld_name)
<< "' unhandled due to unknown type: "
<< fld_type << std::endl;
}
#endif
}
}
return found_table;
}
bool CGUIWindowAddonBrowser::GetDirectory(const std::string& strDirectory, CFileItemList& items)
{
bool result;
if (URIUtils::PathEquals(strDirectory, "addons://downloading/"))
{
VECADDONS addons;
CAddonInstaller::GetInstance().GetInstallList(addons);
CURL url(strDirectory);
CAddonsDirectory::GenerateAddonListing(url, addons, items, g_localizeStrings.Get(24067));
result = true;
items.SetPath(strDirectory);
if (m_guiState.get() && !m_guiState->HideParentDirItems())
{
CFileItemPtr pItem(new CFileItem(".."));
pItem->SetPath(m_history.GetParentPath());
pItem->m_bIsFolder = true;
pItem->m_bIsShareOrDrive = false;
items.AddFront(pItem, 0);
}
}
else
{
result = CGUIMediaWindow::GetDirectory(strDirectory, items);
if (result && CAddonsDirectory::IsRepoDirectory(CURL(strDirectory)))
{
if (CSettings::GetInstance().GetBool(CSettings::SETTING_GENERAL_ADDONFOREIGNFILTER))
{
int i = 0;
while (i < items.Size())
{
auto prop = items[i]->GetProperty("Addon.Language");
if (!prop.isNull() && IsForeign(prop.asString()))
items.Remove(i);
else
++i;
}
}
if (CSettings::GetInstance().GetBool(CSettings::SETTING_GENERAL_ADDONBROKENFILTER))
{
for (int i = items.Size() - 1; i >= 0; i--)
{
if (!items[i]->GetProperty("Addon.Broken").empty())
{
//check if it's installed
AddonPtr addon;
if (!CAddonMgr::GetInstance().GetAddon(items[i]->GetProperty("Addon.ID").asString(), addon))
items.Remove(i);
}
}
}
}
}
if (strDirectory.empty() && CAddonInstaller::GetInstance().IsDownloading())
{
CFileItemPtr item(new CFileItem("addons://downloading/", true));
item->SetLabel(g_localizeStrings.Get(24067));
item->SetLabelPreformated(true);
item->SetIconImage("DefaultNetwork.png");
items.Add(item);
}
items.SetContent("addons");
for (int i = 0; i < items.Size(); ++i)
SetItemLabel2(items[i]);
return result;
}
void WfutSession::startUpdate(const std::string &serverRoot,
const std::string &channelName,
const std::string &localPath,
const std::string &systemPath
)
{
S_LOG_VERBOSE("Channel name: " << channelName);
// This is the base path for all files that will be downloaded
const std::string local_root = localPath + "/" + channelName + "/";
std::string channel(channelName);
std::string channel_file = "wfut.xml";
std::string tmpfile = "tempwfut.xml";
// Look for mLocal mWfutClient file.
mLocalWfut = std::string(localPath + "/" + channelName + "/" + channel_file);
S_LOG_VERBOSE("Local wfut: " << mLocalWfut);
if (fileExists(mLocalWfut)) {
if (mWfutClient.getLocalList(mLocalWfut, mLocal)) {
S_LOG_WARNING("Error reading local wfut.xml file.");
}
}
// Look for tmpwfut file. If it exists, update the mLocal files list.
const std::string tmp_wfut = localPath + "/" + tmpfile;
S_LOG_VERBOSE("Tmp wfut: " << tmp_wfut);
if (fileExists(tmp_wfut)) {
if (mWfutClient.getLocalList(tmp_wfut, mTmplist)) {
S_LOG_WARNING("Error reading local tmpwfut.xml file.");
} else {
const FileMap &fm = mTmplist.getFiles();
FileMap::const_iterator I = fm.begin();
FileMap::const_iterator Iend = fm.end();
for (; I != Iend; ++I) {
mLocal.addFile(I->second);
}
}
}
// Look for a mSystem mWfutClient file
if (!systemPath.empty()) {
const std::string system_wfut = systemPath + "/" + channel + "/" + channel_file;
S_LOG_VERBOSE("System wfut: " << system_wfut);
if (fileExists(system_wfut)) {
if (mWfutClient.getLocalList(system_wfut, mSystem)) {
S_LOG_WARNING("Error reading system wfut.xml file.");
}
}
}
// By now we should have a proper channel name. If not, then there is nothing
// we can do to find the mServer mUpdates.
if (channel.empty() || channel == ".") {
S_LOG_WARNING("Unable to determine channel name.");
return;
}
const std::string server_wfut = serverRoot + "/" + channel + "/" + channel_file;
S_LOG_VERBOSE("Server wfut: " << server_wfut);
mServerListDownloadingSlot(server_wfut);
if (mWfutClient.getFileList(server_wfut, mServer)) {
S_LOG_WARNING("Error downloading server channel file.");
return;
}
S_LOG_VERBOSE("Local Root: " << local_root);
S_LOG_INFO("Updating Channel: " << channel);
// Now we have loaded all our data files, lets find out what we really need
// to download
if (mWfutClient.calculateUpdates(mServer, mSystem, mLocal, mUpdates, local_root)) {
S_LOG_WARNING("Error determining file to update.");
return;
}
mUpdatesCalculatedSlot(mUpdates.getFiles().size());
// Make sure the mLocal file has the correct channel name
mLocal.setName(mServer.getName());
// Queue the list of files to download
mWfutClient.updateChannel(mUpdates, serverRoot + "/" + channel, local_root);
}
int create_listener (
listener*& new_listener,
unsigned short port,
const std::string& ip
)
{
// ensure that WSAStartup has been called and WSACleanup will eventually
// be called when program ends
sockets_startup();
sockaddr_in sa; // local socket structure
ZeroMemory(&sa,sizeof(sockaddr_in)); // initialize sa
SOCKET sock = socket (AF_INET, SOCK_STREAM, 0); // get a new socket
// if socket() returned an error then return OTHER_ERROR
if (sock == INVALID_SOCKET )
{
return OTHER_ERROR;
}
// set the local socket structure
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
if (ip.empty())
{
// if the listener should listen on any IP
sa.sin_addr.S_un.S_addr = htons(INADDR_ANY);
}
else
{
// if there is a specific ip to listen on
sa.sin_addr.S_un.S_addr = inet_addr(ip.c_str());
// if inet_addr cound't convert the ip then return an error
if ( sa.sin_addr.S_un.S_addr == INADDR_NONE )
{
closesocket(sock);
return OTHER_ERROR;
}
}
// set the SO_REUSEADDR option
int flag_value = 1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,reinterpret_cast<const char*>(&flag_value),sizeof(int));
// bind the new socket to the requested port and ip
if (bind(sock,reinterpret_cast<sockaddr*>(&sa),sizeof(sockaddr_in))==SOCKET_ERROR)
{ // if there was an error
closesocket(sock);
// if the port is already bound then return PORTINUSE
if (WSAGetLastError() == WSAEADDRINUSE)
return PORTINUSE;
else
return OTHER_ERROR;
}
// tell the new socket to listen
if ( listen(sock,SOMAXCONN) == SOCKET_ERROR)
{
// if there was an error return OTHER_ERROR
closesocket(sock);
// if the port is already bound then return PORTINUSE
if (WSAGetLastError() == WSAEADDRINUSE)
return PORTINUSE;
else
return OTHER_ERROR;
}
// determine the port used if necessary
if (port == 0)
{
sockaddr_in local_info;
int length = sizeof(sockaddr_in);
if ( getsockname (
sock,
reinterpret_cast<sockaddr*>(&local_info),
&length
) == SOCKET_ERROR
)
{
closesocket(sock);
return OTHER_ERROR;
}
port = ntohs(local_info.sin_port);
}
// initialize a listener object on the heap with the new socket
try { new_listener = new listener(sock,port,ip); }
catch(...) { closesocket(sock); return OTHER_ERROR; }
return 0;
}
bool
BasicModem::processInput(std::string& str)
{
bool got_line = false;
while (!m_chars.empty())
{
char c = m_chars.front();
m_chars.pop();
m_line.push_back(c);
//!@fixme: concurrency hazard.
if (c == m_line_term_in[m_line_term_idx])
{
++m_line_term_idx;
if (m_line_term_idx == m_line_term_in.size())
{
m_line_term_idx = 0;
got_line = true;
break;
}
}
else
{
}
}
if (isFragment(m_line))
{
getTask()->inf(DTR("fragment: %s"), Streams::sanitize(m_line).c_str());
return false;
}
// No complete line is available.
if (!got_line)
return false;
if (m_line.size() <= m_line_term_in.size())
{
str = "";
return true;
}
// Remove termination characters.
str = m_line;
str.resize(m_line.size() - m_line_term_in.size());
if (m_line_trim)
str = Utils::String::trim(str);
// Got a complete line, but it's empty.
if (str.empty())
return true;
m_task->spew("recv: %s", Streams::sanitize(str).c_str());
m_line.clear();
if (!m_skip_line.empty())
{
if (m_skip_line == str)
{
str.clear();
m_skip_line.clear();
}
}
return true;
}
int create_connection (
connection*& new_connection,
unsigned short foreign_port,
const std::string& foreign_ip,
unsigned short local_port,
const std::string& local_ip
)
{
// ensure that WSAStartup has been called and WSACleanup
// will eventually be called when program ends
sockets_startup();
sockaddr_in local_sa; // local socket structure
sockaddr_in foreign_sa; // foreign socket structure
ZeroMemory(&local_sa,sizeof(sockaddr_in)); // initialize local_sa
ZeroMemory(&foreign_sa,sizeof(sockaddr_in)); // initialize foreign_sa
int length;
SOCKET sock = socket (AF_INET, SOCK_STREAM, 0); // get a new socket
// if socket() returned an error then return OTHER_ERROR
if (sock == INVALID_SOCKET )
{
return OTHER_ERROR;
}
// set the foreign socket structure
foreign_sa.sin_family = AF_INET;
foreign_sa.sin_port = htons(foreign_port);
foreign_sa.sin_addr.S_un.S_addr = inet_addr(foreign_ip.c_str());
// if inet_addr cound't convert the ip then return an error
if ( foreign_sa.sin_addr.S_un.S_addr == INADDR_NONE )
{
closesocket(sock);
return OTHER_ERROR;
}
// set up the local socket structure
local_sa.sin_family = AF_INET;
// set the local ip
if (local_ip.empty())
{
// if the listener should listen on any IP
local_sa.sin_addr.S_un.S_addr = htons(INADDR_ANY);
}
else
{
// if there is a specific ip to listen on
local_sa.sin_addr.S_un.S_addr = inet_addr(local_ip.c_str());
// if inet_addr couldn't convert the ip then return an error
if (local_sa.sin_addr.S_un.S_addr == INADDR_NONE)
{
closesocket(sock);
return OTHER_ERROR;
}
}
// set the local port
local_sa.sin_port = htons(local_port);
// bind the new socket to the requested local port and local ip
if ( bind (
sock,
reinterpret_cast<sockaddr*>(&local_sa),
sizeof(sockaddr_in)
) == SOCKET_ERROR
)
{ // if there was an error
closesocket(sock);
// if the port is already bound then return PORTINUSE
if (WSAGetLastError() == WSAEADDRINUSE)
return PORTINUSE;
else
return OTHER_ERROR;
}
// connect the socket
if (connect (
sock,
reinterpret_cast<sockaddr*>(&foreign_sa),
sizeof(sockaddr_in)
) == SOCKET_ERROR
)
{
closesocket(sock);
// if the port is already bound then return PORTINUSE
if (WSAGetLastError() == WSAEADDRINUSE)
return PORTINUSE;
else
return OTHER_ERROR;
}
// determine the local port and IP and store them in used_local_ip
// and used_local_port
int used_local_port;
std::string used_local_ip;
sockaddr_in local_info;
if (local_port == 0)
{
length = sizeof(sockaddr_in);
if (getsockname (
sock,
reinterpret_cast<sockaddr*>(&local_info),
&length
) == SOCKET_ERROR
)
{
closesocket(sock);
return OTHER_ERROR;
}
used_local_port = ntohs(local_info.sin_port);
}
else
{
used_local_port = local_port;
}
// determine real local ip
if (local_ip.empty())
{
// if local_port is not 0 then we must fill the local_info structure
if (local_port != 0)
{
length = sizeof(sockaddr_in);
if ( getsockname (
sock,
reinterpret_cast<sockaddr*>(&local_info),
&length
) == SOCKET_ERROR
)
{
closesocket(sock);
return OTHER_ERROR;
}
}
char* temp = inet_ntoa(local_info.sin_addr);
// check if inet_ntoa returned an error
if (temp == NULL)
{
closesocket(sock);
return OTHER_ERROR;
}
used_local_ip.assign(temp);
}
else
{
used_local_ip = local_ip;
}
// set the SO_OOBINLINE option
int flag_value = 1;
if (setsockopt(sock,SOL_SOCKET,SO_OOBINLINE,reinterpret_cast<const char*>(&flag_value),sizeof(int)) == SOCKET_ERROR )
{
closesocket(sock);
return OTHER_ERROR;
}
// initialize a connection object on the heap with the new socket
try
{
new_connection = new connection (
sock,
foreign_port,
foreign_ip,
used_local_port,
used_local_ip
);
}
catch(...) {closesocket(sock); return OTHER_ERROR; }
return 0;
}
int main( int ac, char** av )
{
try
{
comma::command_line_options options( ac, av );
verbose = options.exists( "--verbose,-v" );
debug = options.exists( "--debug" );
append = options.exists( "--append,-a" );
if( options.exists( "--help,-h" ) ) { usage( verbose ); }
if( options.exists( "--input-fields" ) ) { std::cout << comma::join( comma::csv::names< interval_t< double > >(), ',' ) << std::endl; return 0; }
if( options.exists( "--output-fields" ) ) { std::cout << comma::join( comma::csv::names< interval_t< double > >(), ',' ) << std::endl; return 0; }
comma::csv::options csv( options );
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< interval_t< double > >(), ',' ); }
if( !csv.has_field( "from,to" ) ) { COMMA_THROW( comma::exception, "expected from and to fields" ); }
options.assert_mutually_exclusive( "--binary,--format" );
if( options.exists( "--binary,-b" ) ) {}
else if( options.exists( "--format" ) ) { csv.format( options.value< std::string >( "--format" ) ); }
else
{
while( std::cin.good() && first_line.empty() ) { std::getline( std::cin, first_line ); }
if( first_line.empty() ) { return 0; }
csv.format( comma::csv::impl::unstructured::guess_format( first_line, csv.delimiter ) );
if( verbose ) { std::cerr << app_name << ": guessed format: " << csv.format().string() << std::endl;; }
}
const std::vector< std::string >& fields = comma::split( csv.fields, ',' );
unsigned int from_index = 0;
unsigned int to_index = 1;
for( unsigned int i = 0; i < fields.size(); ++i ) { if( fields[i] == "from" ) { from_index = i; break; } }
for( unsigned int i = 0; i < fields.size(); ++i ) { if( fields[i] == "to" ) { to_index = i; break; } }
const comma::csv::format::types_enum from_type = csv.format().offset( from_index ).type;
const comma::csv::format::types_enum to_type = csv.format().offset( to_index ).type;
if( ( ( from_type == comma::csv::format::time || from_type == comma::csv::format::long_time ) && ( to_type != comma::csv::format::time && to_type != comma::csv::format::long_time ) ) ||
( ( ( from_type != comma::csv::format::time && from_type != comma::csv::format::long_time ) && ( to_type == comma::csv::format::time || to_type == comma::csv::format::long_time ) ) ) )
{ COMMA_THROW( comma::exception, "from/to type mismatch; time" ); }
if( ( from_type == comma::csv::format::fixed_string || to_type == comma::csv::format::fixed_string ) && from_type != to_type )
{ COMMA_THROW( comma::exception, "from/to type mismatch; string" ); }
// switch( from_type )
// {
// case comma::csv::format::int8: run< char >( options, to_type ); break;
// case comma::csv::format::uint8: run< unsigned char >( options, to_type ); break;
// case comma::csv::format::int16: run< comma::int16 >( options, to_type ); break;
// case comma::csv::format::uint16: run< comma::uint16 >( options, to_type ); break;
// case comma::csv::format::int32: run< comma::int32 >( options, to_type ); break;
// case comma::csv::format::uint32: run< comma::uint32 >( options, to_type ); break;
// case comma::csv::format::int64: run< comma::int64 >( options, to_type ); break;
// case comma::csv::format::uint64: run< comma::uint64 >( options, to_type ); break;
// case comma::csv::format::char_t: run< char >( options, to_type ); break;
// case comma::csv::format::float_t: run< float >( options, to_type ); break;
// case comma::csv::format::double_t: run< double >( options, to_type ); break;
// case comma::csv::format::time:
// case comma::csv::format::long_time: intervals< boost::posix_time::ptime >( options ).run(); break;
// case comma::csv::format::fixed_string: intervals< std::string >( options ).run(); break;
// default: COMMA_THROW( comma::exception, "unknown type" ); break;
// }
if( from_type != to_type ) { std::cerr << app_name << ": support only from and to of the same type, got from: " << comma::csv::format::to_format( from_type ) << ", to: " << comma::csv::format::to_format( to_type ) << std::endl; return 1; }
switch( to_type )
{
case comma::csv::format::int8: intervals< char >( options ).run(); break;
case comma::csv::format::uint8: intervals< unsigned char >( options ).run(); break;
case comma::csv::format::int16: intervals< comma::int16 >( options ).run(); break;
case comma::csv::format::uint16: intervals< comma::uint16 >( options ).run(); break;
case comma::csv::format::int32: intervals< comma::int32 >( options ).run(); break;
case comma::csv::format::uint32: intervals< comma::uint32 >( options ).run(); break;
case comma::csv::format::int64: intervals< comma::int64 >( options ).run(); break;
case comma::csv::format::uint64: intervals< comma::uint64 >( options ).run(); break;
case comma::csv::format::char_t: intervals< char >( options ).run(); break;
case comma::csv::format::float_t: intervals< float >( options ).run(); break;
case comma::csv::format::double_t: intervals< double >( options ).run(); break;
case comma::csv::format::time:
case comma::csv::format::long_time: intervals< boost::posix_time::ptime >( options ).run(); break;
case comma::csv::format::fixed_string: intervals< std::string >( options ).run(); break;
default: COMMA_THROW( comma::exception, "from/to type mismatch" ); break;
}
return 0;
}
catch( std::exception& ex ) { std::cerr << app_name << ": " << ex.what() << std::endl; }
catch( ... ) { std::cerr << app_name << ": unknown exception" << std::endl; }
return 1;
}
FEELPP_EXPORT
void ginacBuildLibrary( GiNaC::lst const& exprs, GiNaC::lst const& syml, std::string const& exprDesc, std::string const& filename, WorldComm const& world,
std::shared_ptr<GiNaC::FUNCP_CUBA>& cfun )
{
// register the GinacExprManager into Feel::Environment so that it gets the
// GinacExprManager is cleared up when the Environment is deleted
static bool observed = false;
if ( !observed )
{
Environment::addDeleteObserver( GinacExprManagerDefaultFileNameDeleter::instance() );
Environment::addDeleteObserver( GinacExprManagerDeleter::instance() );
observed = true;
}
std::string keyExprManager = exprDesc;
if ( exprDesc.empty() && !filename.empty() )
keyExprManager = filename;
bool hasLinked = ( GinacExprManager::instance().find( keyExprManager /*exprDesc*/ /*filename*/ ) != GinacExprManager::instance().end() ) ? true : false;
if ( hasLinked )
{
cfun = GinacExprManager::instance().find( keyExprManager /*exprDesc*/ /*filename*/ )->second;
}
else
{
std::string filenameDescExpr = filename + ".desc";
std::string filenameWithSuffix = filename + ".so";
if ( !fs::path(filename).is_absolute() )
{
filenameDescExpr = Environment::exprRepository() + filename + ".desc";
filenameWithSuffix = Environment::exprRepository() + filename + ".so";
}
bool doRebuildGinacLib = true;
// load .desc file and compare if both expr are identical
if ( world.isMasterRank() && !filename.empty() && fs::exists( filenameDescExpr ) && fs::exists( filenameWithSuffix ) )
{
std::string exprInFile;
std::ifstream file( filenameDescExpr, std::ios::in );
std::getline( file, exprInFile );
file.close();
// if equal else not rebuild ginac
if ( exprInFile == exprDesc )
doRebuildGinacLib = false;
}
// master rank check if the lib exist and compile this one if not done
if ( ( world.isMasterRank() && doRebuildGinacLib ) || filename.empty() )
{
if ( !filename.empty() && fs::path( filename ).is_absolute() )
{
if ( !fs::exists( fs::path( filename ).parent_path() ) )
fs::create_directories( fs::path( filename ).parent_path() );
DVLOG( 2 ) << "GiNaC::compile_ex with filenameWithSuffix " << filenameWithSuffix << "\n";
GiNaC::compile_ex( exprs, syml, *cfun, filename );
}
else if ( !filename.empty() )
{
DVLOG( 2 ) << "GiNaC::compile_ex with filenameWithSuffix " << filenameWithSuffix << "\n";
GiNaC::compile_ex( exprs, syml, *cfun, Environment::exprRepository() + "/" + filename );
}
else
{
DVLOG( 2 ) << "GiNaC::compile_ex with filenameWithSuffix " << filenameWithSuffix << "\n";
GiNaC::compile_ex( exprs, syml, *cfun, filename );
}
hasLinked = true;
if ( !filename.empty() )
{
GinacExprManager::instance().operator[]( keyExprManager /*exprDesc*/ /*filename*/ ) = cfun;
if ( !exprDesc.empty() )
{
std::ofstream file( filenameDescExpr, std::ios::out | std::ios::trunc );
file << exprDesc;
file.close();
}
}
}
// wait the lib compilation
if ( !filename.empty() )
world.barrier();
// link with other process
if ( !hasLinked )
{
DVLOG( 2 ) << "GiNaC::link_ex with filenameWithSuffix " << filenameWithSuffix << "\n";
GiNaC::link_ex( filenameWithSuffix, *cfun );
if ( !filename.empty() )
GinacExprManager::instance().operator[]( keyExprManager /*exprDesc*/ /*filename*/ ) = cfun;
}
}
}
bool p2p::isLocalHostAddress(std::string const& _addressToCheck)
{
return _addressToCheck.empty() ? false : isLocalHostAddress(bi::address::from_string(_addressToCheck));
}
/// \brief When the source code line we want to print is too long for
/// the terminal, select the "interesting" region.
static void selectInterestingSourceRegion(std::string &SourceLine,
std::string &CaretLine,
std::string &FixItInsertionLine,
unsigned Columns,
const SourceColumnMap &map) {
unsigned MaxColumns = std::max<unsigned>(map.columns(),
std::max(CaretLine.size(),
FixItInsertionLine.size()));
// if the number of columns is less than the desired number we're done
if (MaxColumns <= Columns)
return;
// No special characters are allowed in CaretLine.
assert(CaretLine.end() ==
std::find_if(CaretLine.begin(), CaretLine.end(),
[](char c) { return c < ' ' || '~' < c; }));
// Find the slice that we need to display the full caret line
// correctly.
unsigned CaretStart = 0, CaretEnd = CaretLine.size();
for (; CaretStart != CaretEnd; ++CaretStart)
if (!isWhitespace(CaretLine[CaretStart]))
break;
for (; CaretEnd != CaretStart; --CaretEnd)
if (!isWhitespace(CaretLine[CaretEnd - 1]))
break;
// caret has already been inserted into CaretLine so the above whitespace
// check is guaranteed to include the caret
// If we have a fix-it line, make sure the slice includes all of the
// fix-it information.
if (!FixItInsertionLine.empty()) {
unsigned FixItStart = 0, FixItEnd = FixItInsertionLine.size();
for (; FixItStart != FixItEnd; ++FixItStart)
if (!isWhitespace(FixItInsertionLine[FixItStart]))
break;
for (; FixItEnd != FixItStart; --FixItEnd)
if (!isWhitespace(FixItInsertionLine[FixItEnd - 1]))
break;
// We can safely use the byte offset FixItStart as the column offset
// because the characters up until FixItStart are all ASCII whitespace
// characters.
unsigned FixItStartCol = FixItStart;
unsigned FixItEndCol
= llvm::sys::locale::columnWidth(FixItInsertionLine.substr(0, FixItEnd));
CaretStart = std::min(FixItStartCol, CaretStart);
CaretEnd = std::max(FixItEndCol, CaretEnd);
}
// CaretEnd may have been set at the middle of a character
// If it's not at a character's first column then advance it past the current
// character.
while (static_cast<int>(CaretEnd) < map.columns() &&
-1 == map.columnToByte(CaretEnd))
++CaretEnd;
assert((static_cast<int>(CaretStart) > map.columns() ||
-1!=map.columnToByte(CaretStart)) &&
"CaretStart must not point to a column in the middle of a source"
" line character");
assert((static_cast<int>(CaretEnd) > map.columns() ||
-1!=map.columnToByte(CaretEnd)) &&
"CaretEnd must not point to a column in the middle of a source line"
" character");
// CaretLine[CaretStart, CaretEnd) contains all of the interesting
// parts of the caret line. While this slice is smaller than the
// number of columns we have, try to grow the slice to encompass
// more context.
unsigned SourceStart = map.columnToByte(std::min<unsigned>(CaretStart,
map.columns()));
unsigned SourceEnd = map.columnToByte(std::min<unsigned>(CaretEnd,
map.columns()));
unsigned CaretColumnsOutsideSource = CaretEnd-CaretStart
- (map.byteToColumn(SourceEnd)-map.byteToColumn(SourceStart));
char const *front_ellipse = " ...";
char const *front_space = " ";
char const *back_ellipse = "...";
unsigned ellipses_space = strlen(front_ellipse) + strlen(back_ellipse);
unsigned TargetColumns = Columns;
// Give us extra room for the ellipses
// and any of the caret line that extends past the source
if (TargetColumns > ellipses_space+CaretColumnsOutsideSource)
TargetColumns -= ellipses_space+CaretColumnsOutsideSource;
while (SourceStart>0 || SourceEnd<SourceLine.size()) {
bool ExpandedRegion = false;
if (SourceStart>0) {
unsigned NewStart = map.startOfPreviousColumn(SourceStart);
// Skip over any whitespace we see here; we're looking for
// another bit of interesting text.
// FIXME: Detect non-ASCII whitespace characters too.
while (NewStart && isWhitespace(SourceLine[NewStart]))
NewStart = map.startOfPreviousColumn(NewStart);
// Skip over this bit of "interesting" text.
while (NewStart) {
unsigned Prev = map.startOfPreviousColumn(NewStart);
if (isWhitespace(SourceLine[Prev]))
break;
NewStart = Prev;
}
assert(map.byteToColumn(NewStart) != -1);
unsigned NewColumns = map.byteToColumn(SourceEnd) -
map.byteToColumn(NewStart);
if (NewColumns <= TargetColumns) {
SourceStart = NewStart;
ExpandedRegion = true;
}
}
if (SourceEnd<SourceLine.size()) {
unsigned NewEnd = map.startOfNextColumn(SourceEnd);
// Skip over any whitespace we see here; we're looking for
// another bit of interesting text.
// FIXME: Detect non-ASCII whitespace characters too.
while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
NewEnd = map.startOfNextColumn(NewEnd);
// Skip over this bit of "interesting" text.
while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
NewEnd = map.startOfNextColumn(NewEnd);
assert(map.byteToColumn(NewEnd) != -1);
unsigned NewColumns = map.byteToColumn(NewEnd) -
map.byteToColumn(SourceStart);
if (NewColumns <= TargetColumns) {
SourceEnd = NewEnd;
ExpandedRegion = true;
}
}
if (!ExpandedRegion)
break;
}
CaretStart = map.byteToColumn(SourceStart);
CaretEnd = map.byteToColumn(SourceEnd) + CaretColumnsOutsideSource;
// [CaretStart, CaretEnd) is the slice we want. Update the various
// output lines to show only this slice, with two-space padding
// before the lines so that it looks nicer.
assert(CaretStart!=(unsigned)-1 && CaretEnd!=(unsigned)-1 &&
SourceStart!=(unsigned)-1 && SourceEnd!=(unsigned)-1);
assert(SourceStart <= SourceEnd);
assert(CaretStart <= CaretEnd);
unsigned BackColumnsRemoved
= map.byteToColumn(SourceLine.size())-map.byteToColumn(SourceEnd);
unsigned FrontColumnsRemoved = CaretStart;
unsigned ColumnsKept = CaretEnd-CaretStart;
// We checked up front that the line needed truncation
assert(FrontColumnsRemoved+ColumnsKept+BackColumnsRemoved > Columns);
// The line needs some trunctiona, and we'd prefer to keep the front
// if possible, so remove the back
if (BackColumnsRemoved > strlen(back_ellipse))
SourceLine.replace(SourceEnd, std::string::npos, back_ellipse);
// If that's enough then we're done
if (FrontColumnsRemoved+ColumnsKept <= Columns)
return;
// Otherwise remove the front as well
if (FrontColumnsRemoved > strlen(front_ellipse)) {
SourceLine.replace(0, SourceStart, front_ellipse);
CaretLine.replace(0, CaretStart, front_space);
if (!FixItInsertionLine.empty())
FixItInsertionLine.replace(0, CaretStart, front_space);
}
}
// virtual
BOOL LLPreviewGesture::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
EDragAndDropType cargo_type,
void* cargo_data,
EAcceptance* accept,
std::string& tooltip_msg)
{
BOOL handled = TRUE;
switch(cargo_type)
{
case DAD_ANIMATION:
case DAD_SOUND:
{
// TODO: Don't allow this if you can't transfer the sound/animation
// make a script step
LLInventoryItem* item = (LLInventoryItem*)cargo_data;
if (item
&& gInventory.getItem(item->getUUID()))
{
LLPermissions perm = item->getPermissions();
if (!((perm.getMaskBase() & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED))
{
*accept = ACCEPT_NO;
if (tooltip_msg.empty())
{
tooltip_msg.assign("Only animations and sounds\n"
"with unrestricted permissions\n"
"can be added to a gesture.");
}
break;
}
else if (drop)
{
LLScrollListItem* line = NULL;
if (cargo_type == DAD_ANIMATION)
{
line = addStep( STEP_ANIMATION );
LLGestureStepAnimation* anim = (LLGestureStepAnimation*)line->getUserdata();
anim->mAnimAssetID = item->getAssetUUID();
anim->mAnimName = item->getName();
}
else if (cargo_type == DAD_SOUND)
{
line = addStep( STEP_SOUND );
LLGestureStepSound* sound = (LLGestureStepSound*)line->getUserdata();
sound->mSoundAssetID = item->getAssetUUID();
sound->mSoundName = item->getName();
}
updateLabel(line);
mDirty = TRUE;
refresh();
}
*accept = ACCEPT_YES_COPY_MULTI;
}
else
{
// Not in user's inventory means it was in object inventory
*accept = ACCEPT_NO;
}
break;
}
default:
*accept = ACCEPT_NO;
if (tooltip_msg.empty())
{
tooltip_msg.assign("Only animations and sounds\n"
"can be added to a gesture.");
}
break;
}
return handled;
}
void Text::init(RCPtr<Font> fnt, const std::string &str, bool use_kerning)
{
assert(fnt.get());
assert(! str.empty());
mFont = fnt;
mVerts.reset(new VertexBuffer((unsigned int)str.size() * 4, kFontVertexFormat, GL_STREAM_DRAW_ARB, false));
VertexBufferLock lock(*mVerts);
float *v = lock.get<float>();
float x = 0.0f, y = 0.0f;
mWidth = 0.0f;
mHeight = 0.0f;
mNumVerts = 0;
char prev_char = 0;
for (size_t i = 0; i < str.size(); ++i)
{
char c = str[i];
if (c == '\r' || c == '\n')
{
++i;
if (i < str.size() && str[i] == '\r' || str[i] == '\n')
++i;
if (i == str.size())
break;
// newline breaks up kerning pairs
prev_char = 0;
mWidth = std::max(mWidth, x);
x = 0.0f;
y += mFont->getLineHeight();
continue;
}
// Get the normal character information
const Font::CharInfo &ci = mFont->getCharInfo(c);
// Get the kerning pair offset, if there is one
float kerning_offset = 0.0f;
if (use_kerning && (prev_char != 0))
kerning_offset = mFont->getKerningOffset(prev_char, c);
prev_char = c;
x += kerning_offset;
if (! ci.draw)
{
x += ci.advance;
continue;
}
// Add the vertices
// TopLeft
*v++ = ci.texTopLeft[0]; // u
*v++ = ci.texTopLeft[1]; // v
*v++ = x + ci.posTopLeft[0]; // x
*v++ = y + ci.posTopLeft[1]; // y
// BottomLeft
*v++ = ci.texTopLeft[0]; // u
*v++ = ci.texBottomRight[1]; // v
*v++ = x + ci.posTopLeft[0]; // x
*v++ = y + ci.posBottomRight[1]; // y
// BottomRight
*v++ = ci.texBottomRight[0]; // u
*v++ = ci.texBottomRight[1]; // v
*v++ = x + ci.posBottomRight[0]; // x
*v++ = y + ci.posBottomRight[1]; // y
// TopRight
*v++ = ci.texBottomRight[0]; // u
*v++ = ci.texTopLeft[1]; // v
*v++ = x + ci.posBottomRight[0]; // x
*v++ = y + ci.posTopLeft[1]; // y
x += ci.advance;
mNumVerts += 4;
}
lock.reset();
mWidth = std::max(x, mWidth);
mHeight = y + mFont->getLineHeight();
}
Path Path::appendExt(const std::string &ext) const
{
if (ext.empty()) return Path(*this);
else if (ext[0] == '.') return Path(data + ext);
else return Path(data + "." + ext);
}
void TlsOptions::setOption( tls_option opt, const std::string& value ) const {
checkOpt(opt, STRING);
this->setOption( opt, value.empty() ? NULL : (void*) value.c_str() );
}
bool ParseFloat(const std::string& string, float& value)
{
return swri_string_util::ToFloat(string, value) || string.empty();
}
void Browser::getDirectory(std::string directory)
{
m_scroll_beginning = 0;
w.clear();
// reset the position if we change directories
if (m_current_directory != directory)
w.reset();
// check if it's a parent directory
if (isStringParentDirectory(directory))
{
directory.resize(directory.length()-3);
directory = getParentDirectory(directory);
}
// when we go down to root, it can be empty
if (directory.empty())
directory = "/";
std::vector<MPD::Item> items;
if (m_local_browser)
getLocalDirectory(items, directory);
else
{
std::copy(
std::make_move_iterator(Mpd.GetDirectory(directory)),
std::make_move_iterator(MPD::ItemIterator()),
std::back_inserter(items)
);
}
// sort items
if (Config.browser_sort_mode != SortMode::NoOp)
{
std::sort(items.begin(), items.end(),
LocaleBasedItemSorting(std::locale(), Config.ignore_leading_the, Config.browser_sort_mode)
);
}
// if the requested directory is not root, add parent directory
if (!isRootDirectory(directory))
{
// make it so that display function doesn't have to handle special cases
w.addItem(MPD::Directory(directory + "/.."), NC::List::Properties::None);
}
for (const auto &item : items)
{
switch (item.type())
{
case MPD::Item::Type::Playlist:
{
w.addItem(std::move(item));
break;
}
case MPD::Item::Type::Directory:
{
bool is_current = item.directory().path() == m_current_directory;
w.addItem(std::move(item));
if (is_current)
w.highlight(w.size()-1);
break;
}
case MPD::Item::Type::Song:
{
auto properties = NC::List::Properties::Selectable;
if (myPlaylist->checkForSong(item.song()))
properties |= NC::List::Properties::Bold;
w.addItem(std::move(item), properties);
break;
}
}
}
m_current_directory = directory;
}
// Main entry point
int main (int argc, char** argv)
{
std::string pathToThisFile=__FILE__;
if(gDataPath.empty())
gDataPath=rt::Math::getParentDirectoryFromFilePath(pathToThisFile);
std::cerr<<"Using data path: "<<gDataPath<<std::endl;
std::cerr<<"Use your mouse to rotate,pan and zoom the camera"<<std::endl;
std::cerr<<"left mouse button + drag -> rotate"<<std::endl;
std::cerr<<"middle mouse button + drag -> pan"<<std::endl;
std::cerr<<"scroll wheel up / down -> zoom in / out"<<std::endl;
if( !glfwInit() )
{
std::cerr<<"Failed to initialize GLFW\n"<<std::endl;
return -1;
}
glfwSetErrorCallback(glfwErrorCallback);
// Create the OpenGL window
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_SAMPLES, 4);
//Those stop GLFW from initializing successfully?
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Open OpenGL fullscreen window
gGLFWWindow = glfwCreateWindow(gWidth,gHeight,"GLFW OpenGL Window",nullptr,nullptr);
//// Open OpenGL fullscreen window
//if( !glfwOpenWindow( gWidth, gHeight, 0,0,0,0, 16,0, GLFW_WINDOW ) )
//{
// fprintf( stderr, "Failed to open GLFW window\n" );
// glfwTerminate();
// exit( EXIT_FAILURE );
//}
if(!gGLFWWindow)
{
std::cerr<<"Failed to open GLFW window\n"<<std::endl;
glfwTerminate();
return -1;
}
// Disable VSync (we want to get as high FPS as possible!)
glfwMakeContextCurrent(gGLFWWindow);
glfwSwapInterval( 1 );
// Setting this is necessary for core profile (tested with MSVC 2013 x64, Windows 7)
glewExperimental = GL_TRUE;
// GLEW wraps all OpenGL functions and extensions
GLenum err = glewInit();
if(err != GLEW_OK)
{
std::cerr<<"Failed to initialize GLEW"<<std::endl;
std::cerr<<(char*)glewGetErrorString(err)<<std::endl;
glfwTerminate();
return -1;
}
glGetError(); //GLEW might cause an 'invalid enum' error, safely ignore it?
// Print OpenGL context information to console
ogl::printContextInformation();
// Perform our initialization (OpenGL states, shader, camera, geometry)
if(!init())
return -1;
// Set the appropriate callback functions
// Window resize callback function
glfwSetFramebufferSizeCallback(gGLFWWindow,resizeCB);
glfwSetMouseButtonCallback(gGLFWWindow,mouseCB);
glfwSetScrollCallback(gGLFWWindow,wheelCB);
glfwSetCursorPosCallback(gGLFWWindow,motionCB);
while( !glfwWindowShouldClose(gGLFWWindow) )
{
// Get the current time (in milliseconds since program start)
double t0 =glfwGetTime();
// Clear frame and depth buffers
glClearColor(gBackgroundColor[0],gBackgroundColor[1],gBackgroundColor[2], 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw...
displayCB();
// Hopefully there hasn't been any mistake?
ogl::printOpenGLError();
// Swap the rendering target with the frame buffer shown on the monitor
glfwSwapBuffers(gGLFWWindow);
glfwPollEvents() ;
// Compute rendering time in seconds by taking difference to current time
double t1=glfwGetTime();
gLastFrameTime = float(t1-t0);
}
// Terminate OpenGL
glfwTerminate();
return 0;
}
void ConfigManager::getChildren(std::string path,
std::vector<std::string> & destList)
{
if(path.empty())
{
return;
}
for(int i = 0; i < _configRootList.size(); i++)
{
std::string pathFrag;
std::string pathRemainder = path;
mxml_node_t * xmlNode = _configRootList[i]->child;
size_t location = pathRemainder.find_first_of('.');
if(location == std::string::npos)
{
pathFrag = pathRemainder;
pathRemainder = "";
}
else
{
pathFrag = pathRemainder.substr(0,location);
if(location + 1 < pathRemainder.size())
{
pathRemainder = pathRemainder.substr(location + 1);
}
else
{
pathRemainder = "";
}
}
std::stack<std::pair<mxml_node_t *,std::string> > parentStack;
do
{
if(!parentStack.empty())
{
xmlNode = parentStack.top().first->next;
if(!pathRemainder.empty())
{
pathRemainder = pathFrag + "." + pathRemainder;
}
else
{
pathRemainder = pathFrag;
}
pathFrag = parentStack.top().second;
parentStack.pop();
}
while(xmlNode)
{
if(xmlNode->type != MXML_ELEMENT)
{
xmlNode = xmlNode->next;
continue;
}
std::string nodeName = xmlNode->value.element.name;
const char * nameAtt = mxmlElementGetAttr(xmlNode,"name");
std::string suffix = nameAtt ? nameAtt : "";
//std::cerr << "Looking at node: " << nodeName << " with suffix " << suffix << std::endl;
location = pathFrag.find_first_of(':');
if((location == std::string::npos && pathFrag == nodeName)
|| (location != std::string::npos
&& pathFrag == nodeName + ":" + suffix))
{
//std::cerr << "Found Fragment." << std::endl;
if(pathRemainder.empty())
{
if(xmlNode->child)
{
mxml_node_t * cnode = xmlNode->child;
while(cnode)
{
if(cnode->type != MXML_ELEMENT)
{
cnode = cnode->next;
continue;
}
// ignore comment tags
if(strncmp(cnode->value.element.name,"!--",3))
{
destList.push_back(
cnode->value.element.name);
}
cnode = cnode->next;
}
}
xmlNode = xmlNode->next;
}
else
{
parentStack.push(
std::pair<mxml_node_t *,std::string>(xmlNode,
pathFrag));
location = pathRemainder.find_first_of('.');
if(location == std::string::npos)
{
pathFrag = pathRemainder;
pathRemainder = "";
}
else
{
pathFrag = pathRemainder.substr(0,location);
if(location + 1 < pathRemainder.size())
{
pathRemainder = pathRemainder.substr(
location + 1);
}
else
{
pathRemainder = "";
}
}
//std::cerr << "Looking for fragment: " << pathFrag << std::endl;
//std::cerr << "with remainder: " << pathRemainder << std::endl;
xmlNode = xmlNode->child;
}
}
else
{
xmlNode = xmlNode->next;
}
}
}
while(!parentStack.empty());
}
return;
}