int Server::LookupCommand(const std::string& uri, const std::string& http_verb, std::wstring* session_id, std::wstring* locator) {
int value = NoCommand;
UrlMap::const_iterator it = this->commands_.begin();
for (; it != this->commands_.end(); ++it) {
std::vector<std::string> locator_param_names;
std::string url_candidate = it->first;
size_t param_start_pos = url_candidate.find_first_of(":");
while (param_start_pos != std::string::npos) {
size_t param_len = std::string::npos;
size_t param_end_pos = url_candidate.find_first_of("/", param_start_pos);
if (param_end_pos != std::string::npos) {
param_len = param_end_pos - param_start_pos;
}
// Skip the colon
std::string param_name = url_candidate.substr(param_start_pos + 1, param_len - 1);
locator_param_names.push_back(param_name);
if (param_name == "sessionid" || param_name == "id") {
url_candidate.replace(param_start_pos, param_len, "([0-9a-fA-F-]+)");
} else {
url_candidate.replace(param_start_pos, param_len, "([^/]+)");
}
param_start_pos = url_candidate.find_first_of(":");
}
std::string::const_iterator uri_start = uri.begin();
std::string::const_iterator uri_end = uri.end();
std::tr1::regex matcher("^" + url_candidate + "$");
std::tr1::match_results<std::string::const_iterator> matches;
if (std::tr1::regex_search(uri_start, uri_end, matches, matcher)) {
VerbMap::const_iterator verb_iterator = it->second.find(http_verb);
if (verb_iterator != it->second.end()) {
value = verb_iterator->second;
std::string param = "{";
size_t param_count = locator_param_names.size();
for (unsigned int i = 0; i < param_count; i++) {
if (i != 0) {
param += ",";
}
std::string locator_param_value(matches[i + 1].first, matches[i + 1].second);
param += " \"" + locator_param_names[i] + "\" : \"" + locator_param_value + "\"";
if (locator_param_names[i] == "sessionid") {
session_id->append(CA2W(locator_param_value.c_str(), CP_UTF8));
}
}
param += " }";
std::wstring wide_param(param.begin(), param.end());
locator->append(wide_param);
break;
} else {
verb_iterator = it->second.begin();
for (; verb_iterator != it->second.end(); ++verb_iterator) {
if (locator->size() != 0) {
locator->append(L",");
}
locator->append(CA2W(verb_iterator->first.c_str(), CP_UTF8));
}
}
}
}
return value;
}
bool is_number(const std::string& s)
{
std::string::const_iterator it = s.begin();
while (it != s.end() && (isdigit(*it) || (*it == '.') || (*it == '-') || (*it == ' ') || (*it == 0x00))) ++it;
return !s.empty() && it == s.end();
}
void copy_call_graph( std::string const & input, std::string & output )
{
#if defined(_MSC_VER) && 0
output.reserve( input.size() );
unsigned int pos ( 0 );
unsigned int counter( 0 );
bool matched( false );
std::string buffer;
std::string::const_iterator p_ch ( input.begin() );
std::string::const_iterator const input_end( input.end () );
while ( p_ch != input_end )
{
char const ch( *p_ch++ );
buffer.push_back( ch );
if ( ch == '\n' )
{
if ( matched )
{
output.append( buffer );
if ( ++counter % 200 == 0 ) std::fprintf( stderr, "On Instantiation %d\n", counter/2 );
buffer.clear();
matched = false;
// process instantiation back-trace
pos = 0;
while ( p_ch != input_end )
{
char const ch( *p_ch++ );
if ( ch == ' ' )
{
buffer.push_back( ch );
while ( p_ch != input_end )
{
char const ch( *p_ch++ );
buffer.push_back( ch );
if ( ch == '\n' )
{
if ( matched )
{
output.append( buffer );
}
buffer.clear();
matched = false;
pos = 0;
break;
}
if ( ch == back_trace_search[ pos ] )
{
++pos;
if ( back_trace_search[ pos ] == '\0' )
{
matched = true;
}
}
else
{
pos = 0;
}
}
}
else
{
--p_ch;
break;
}
}
}
buffer.clear();
matched = false;
pos = 0;
}
if ( ch == search[ pos ] )
{
++pos;
if ( search[ pos ] == '\0' )
{
matched = true;
}
}
else
{
pos = 0;
}
}
#elif defined(__GNUC__) || 1
// trying to figure out what we should copy is too hard.
output = input;
#else
#error Unknown compiler
#endif
}
void Signature::setQuirksSignature( std::string fp )
{
quirks_ = 0;
/*
* Quirks section is usually an empty list ('.') of oddities or bugs of this
* particular stack. List items are not separated in any way. Possible values:
*
* P - options past EOL,
* Z - zero IP ID,
* I - IP options specified,
* U - urg pointer non-zero,
* X - unused (x2) field non-zero,
* A - ACK number non-zero,
* T - non-zero second timestamp,
* F - unusual flags (PUSH, URG, etc),
* D - data payload,
* ! - broken options segment.
*/
std::string::iterator itr;
for( itr = fp.begin(); itr != fp.end(); ++itr )
{
switch( tolower(*itr) )
{
case 'p':
quirks_ |= QUIRK_PAST;
break;
case 'z':
quirks_ |= QUIRK_ZEROID;
break;
case 'i':
quirks_ |= QUIRK_IPOPT;
break;
case 'u':
quirks_ |= QUIRK_URG;
break;
case 'x':
quirks_ |= QUIRK_X2;
break;
case 'a':
quirks_ |= QUIRK_ACK;
break;
case 't':
quirks_ |= QUIRK_T2;
break;
case 'f':
quirks_ |= QUIRK_FLAGS;
break;
case 'd':
quirks_ |= QUIRK_DATA;
break;
case '!':
quirks_ |= QUIRK_BROKEN;
break;
case 'k':
quirks_ |= QUIRK_RSTACK;
break;
case 'q':
quirks_ |= QUIRK_SEQEQ;
break;
case '0':
quirks_ |= QUIRK_SEQ0;
break;
}
}
}
void ByteBuffer::SerializeString(const std::string &str) {
for (std::string::const_iterator i = str.begin();
i != str.end(); ++i)
buffer.push_back(*i);
buffer.push_back('\0');
}
void RequestHandler::handle_request(const http::Request &req, http::Reply &reply)
{
// parse command
try
{
std::string request;
URIDecode(req.uri, request);
// deactivated as GCC apparently does not implement that, not even in 4.9
// std::time_t t = std::time(nullptr);
// SimpleLogger().Write() << std::put_time(std::localtime(&t), "%m-%d-%Y %H:%M:%S") <<
// " " << req.endpoint.to_string() << " " <<
// req.referrer << ( 0 == req.referrer.length() ? "- " :" ") <<
// req.agent << ( 0 == req.agent.length() ? "- " :" ") << request;
time_t ltime;
struct tm *Tm;
ltime = time(nullptr);
Tm = localtime(<ime);
// log timestamp
SimpleLogger().Write() << (Tm->tm_mday < 10 ? "0" : "") << Tm->tm_mday << "-"
<< (Tm->tm_mon + 1 < 10 ? "0" : "") << (Tm->tm_mon + 1) << "-"
<< 1900 + Tm->tm_year << " " << (Tm->tm_hour < 10 ? "0" : "")
<< Tm->tm_hour << ":" << (Tm->tm_min < 10 ? "0" : "") << Tm->tm_min
<< ":" << (Tm->tm_sec < 10 ? "0" : "") << Tm->tm_sec << " "
<< req.endpoint.to_string() << " " << req.referrer
<< (0 == req.referrer.length() ? "- " : " ") << req.agent
<< (0 == req.agent.length() ? "- " : " ") << request;
RouteParameters route_parameters;
APIGrammarParser api_parser(&route_parameters);
auto iter = request.begin();
const bool result = boost::spirit::qi::parse(iter, request.end(), api_parser);
// check if the was an error with the request
if (!result || (iter != request.end()))
{
reply = http::Reply::StockReply(http::Reply::badRequest);
reply.content.clear();
const unsigned position = static_cast<unsigned>(std::distance(request.begin(), iter));
JSON::Object json_result;
json_result.values["status"] = 400;
std::string message = "Query string malformed close to position ";
message += UintToString(position);
json_result.values["status_message"] = message;
JSON::render(reply.content, json_result);
return;
}
// parsing done, lets call the right plugin to handle the request
BOOST_ASSERT_MSG(routing_machine != nullptr, "pointer not init'ed");
if (!route_parameters.jsonp_parameter.empty())
{ // prepend response with jsonp parameter
const std::string json_p = (route_parameters.jsonp_parameter + "(");
reply.content.insert(reply.content.end(), json_p.begin(), json_p.end());
}
routing_machine->RunQuery(route_parameters, reply);
if (!route_parameters.jsonp_parameter.empty())
{ // append brace to jsonp response
reply.content.push_back(')');
}
reply.headers.emplace_back("Access-Control-Allow-Origin", "*");
reply.headers.emplace_back("Access-Control-Allow-Methods", "GET");
reply.headers.emplace_back("Access-Control-Allow-Headers", "X-Requested-With, Content-Type");
// set headers
reply.headers.emplace_back("Content-Length",
UintToString(static_cast<unsigned>(reply.content.size())));
if ("gpx" == route_parameters.output_format)
{ // gpx file
reply.headers.emplace_back("Content-Type", "application/gpx+xml; charset=UTF-8");
reply.headers.emplace_back("Content-Disposition", "attachment; filename=\"route.gpx\"");
}
else if (route_parameters.jsonp_parameter.empty())
{ // json file
reply.headers.emplace_back("Content-Type", "application/json; charset=UTF-8");
reply.headers.emplace_back("Content-Disposition", "inline; filename=\"response.json\"");
}
else
{ // jsonp
reply.headers.emplace_back("Content-Type", "text/javascript; charset=UTF-8");
reply.headers.emplace_back("Content-Disposition", "inline; filename=\"response.js\"");
}
}
catch (const std::exception &e)
{
reply = http::Reply::StockReply(http::Reply::internalServerError);
SimpleLogger().Write(logWARNING) << "[server error] code: " << e.what()
<< ", uri: " << req.uri;
return;
}
}
void Parser_XML::erase_all_characters(std::string& str, char character)
{
str.erase(std::remove(str.begin(), str.end(), character), str.end());
}
void leftTrimString(std::string & str) noexcept {
auto begin(str.begin());
str.erase(begin, std::find_if_not(begin, str.end(), charIsSpace));
}
void rightTrimString(std::string & str) noexcept {
str.erase(std::find_if_not(str.rbegin(), str.rend(), charIsSpace).base(),
str.end());
}
/** Test equality between two strings without regard to case. */
inline UTILITIES_API bool istringEqual(const std::string& x, const std::string& y){
return x.size() == y.size() &&
std::equal(x.begin(), x.end(), y.begin(), IcharCompare());
};
node parser::parseline(std::string linha){
linha.append(" "); // <--- super gambiarra, colocando espaço no final pro algoritmo funcionar
int flag_label = 0; //se ja tiver setado como 1, ou é o comando ou é parametro
int flag_comando = 0; //se ja tiver setado, primeiro parametro foi armazenado
int flag_parametro = 0; //para indicar se o primeiro parametro ja existe
std::string::iterator itr;
std::string buffer;
node r_node;
if(linha == "") //retorna nó vazio se a linha for vazia
return r_node;
//itera toda a linha
for(itr = linha.begin() ; itr != linha.end() ; itr++){
//se caractere nao for espaço, armazena na palavra
if((*itr) != ' ' && (*itr) != ',')
buffer.push_back((*itr));
/*
* se for espaço (final de palavra), verifica se é palavra chave.
* se for, armazena no atributo comando e seta flag comando para 1
* se nao for, armazena no atributo label, e seta label para 1
* se comando ja tiver setado em um, só pode ser parametro. seta parametro para 1
* se parametro ja tiver setado, só pode ser segundo parametro
*/
else{
std::cout << "WORD = " << buffer << std::endl;
//buffer.clear();
//caso seja palavra chave
if(iskeyword(buffer) && !(buffer.empty())){
flag_comando = 1;
r_node.comando = buffer;
buffer.clear();
}
//caso nao seja palavra chave e comando nao tenha sido encontrado ainda
if(flag_comando == 0 && !(buffer.empty())){
flag_label = 1;
r_node.label = buffer;
buffer.clear();
}
//caso comando ja tenha sido armazenado, prox palavra tem que ser parametro
if(flag_comando == 1 && flag_parametro == 0 && !(buffer.empty())){
flag_parametro = 1;
r_node.parametro1 = buffer;
buffer.clear();
}
//caso primeiro parametro ja exista
if(flag_parametro == 1 && !(buffer.empty())){
r_node.parametro2 = buffer;
buffer.clear();
}
/* ---------------------------- COMEÇO DO CODIGO ZUADO
if(iskeyword(buffer)){
flag_comando = 1;
return_node.comando = buffer;
buffer.clear();
}
else{
//se nao for keyword e label for zero, entao é label
if(flag_label == 0){
flag_label = 1;
return_node.label = buffer;
buffer.clear();
}
else{
//se comando e label ja existirem, entao é o primeiro parametro
if(flag_parametro == 0){
flag_parametro = 1;
return_node.parametro1 = buffer;
buffer.clear();
}
//se comando, label e o primeiro parametro ja existirem,
//entao é o segundo parametro
else{
return_node.parametro2 = buffer;
buffer.clear();
}
}
}
------------------------------- FIM DO CODIGO ZUADO */
}
}
return r_node;
}
void TickerInfoManager::put(std::string const& id, int total, int active) {
SharedString shid(id.begin(), id.end(), pimpl_->m_alloc);
lock_guard lock(pimpl_->mutex());
pimpl_->map()[shid] = { total, active };
}
static std::string unquote(std::string s)
{
if(s.empty() || s[0] != '"' || s.size() <= 2)
return s;
return std::string(++s.begin(), --s.end());
}
void reverse()
{
std::reverse(spattern.begin(),spattern.end());
pattern = spattern.c_str();
}
int skill_string_to_enum(std::string skillname)
{
std::transform(skillname.begin(), skillname.end(), skillname.begin(), ::tolower);
if (skillname == "handtohand")
return SKILL_HANDTOHAND;
else if (skillname == "knife")
return SKILL_KNIFE;
else if (skillname == "sword")
return SKILL_SWORD;
else if (skillname == "club")
return SKILL_CLUB;
else if (skillname == "axe")
return SKILL_AXE;
else if (skillname == "throwing")
return SKILL_THROWING;
else if (skillname == "pistol")
return SKILL_PISTOL;
else if (skillname == "rifle")
return SKILL_RIFLE;
else if (skillname == "smg")
return SKILL_SMG;
else if (skillname == "shotgun")
return SKILL_SHOTGUN;
else if (skillname == "persuasion")
return SKILL_PERSUASION;
else if (skillname == "psychology")
return SKILL_PSYCHOLOGY;
else if (skillname == "law")
return SKILL_LAW;
else if (skillname == "security")
return SKILL_SECURITY;
else if (skillname == "disguise")
return SKILL_DISGUISE;
else if (skillname == "computers")
return SKILL_COMPUTERS;
else if (skillname == "tailoring")
return SKILL_TAILORING;
else if (skillname == "driving")
return SKILL_DRIVING;
else if (skillname == "writing")
return SKILL_WRITING;
else if (skillname == "music")
return SKILL_MUSIC;
else if (skillname == "art")
return SKILL_ART;
else if (skillname == "religion")
return SKILL_RELIGION;
else if (skillname == "science")
return SKILL_SCIENCE;
else if (skillname == "business")
return SKILL_BUSINESS;
else if (skillname == "stealth")
return SKILL_STEALTH;
else if (skillname == "teaching")
return SKILL_TEACHING;
else if (skillname == "streetsense")
return SKILL_STREETSENSE;
else if (skillname == "seduction")
return SKILL_SEDUCTION;
else if (skillname == "firstaid")
return SKILL_FIRSTAID;
else if (skillname == "dodge")
return SKILL_DODGE;
else if (skillname == "heavyweapons")
return SKILL_HEAVYWEAPONS;
else
return -1;
}
tstring OemToTChar(const std::string& text)
{
tstring result(text.begin(), text.end());
::OemToChar(text.c_str(), &(result[0]));
return result;
}
class TestBase : public section::Base {
public:
TestBase( double ZA, double AWR, int MT ) : Base( ZA, AWR, MT ) {};
TestBase( const HEAD& head, int MAT, int MF ) : Base( head, MAT, MF ) {};
};
SCENARIO( "section::Base tests") {
GIVEN( "a string representing the Section" ) {
std::string line = chunk();
auto begin = line.begin();
auto end = line.end();
long lineNumber = 2;
auto head = StructureDivision( begin, end, lineNumber );
std::unique_ptr<TestBase> base;
WHEN( "given good MAT, MF numbers"){
int MAT = 125;
int MF = 3;
THEN( "the base can be constructed without throwing" ) {
REQUIRE_NOTHROW(
base = std::make_unique<TestBase>( asHead(head), MAT, MF) );
AND_THEN( "we can get the ZA, MT, and atomicWeightRatio" ) {
tstring C2T(const std::string& text)
{
return tstring(text.begin(), text.end());
}
void postgresql_statement_backend::prepare(std::string const & query,
statement_type stType)
{
#ifdef SOCI_POSTGRESQL_NOBINDBYNAME
query_ = query;
#else
// rewrite the query by transforming all named parameters into
// the postgresql_ numbers ones (:abc -> $1, etc.)
enum { normal, in_quotes, in_name } state = normal;
std::string name;
int position = 1;
for (std::string::const_iterator it = query.begin(), end = query.end();
it != end; ++it)
{
switch (state)
{
case normal:
if (*it == '\'')
{
query_ += *it;
state = in_quotes;
}
else if (*it == ':')
{
// Check whether this is a cast operator (e.g. 23::float)
// and treat it as a special case, not as a named binding
const std::string::const_iterator next_it = it + 1;
if ((next_it != end) && (*next_it == ':'))
{
query_ += "::";
++it;
}
else
{
state = in_name;
}
}
else // regular character, stay in the same state
{
query_ += *it;
}
break;
case in_quotes:
if (*it == '\'')
{
query_ += *it;
state = normal;
}
else // regular quoted character
{
query_ += *it;
}
break;
case in_name:
if (std::isalnum(*it) || *it == '_')
{
name += *it;
}
else // end of name
{
names_.push_back(name);
name.clear();
std::ostringstream ss;
ss << '$' << position++;
query_ += ss.str();
query_ += *it;
state = normal;
// Check whether the named parameter is immediatelly
// followed by a cast operator (e.g. :name::float)
// and handle the additional colon immediately to avoid
// its misinterpretation later on.
if (*it == ':')
{
const std::string::const_iterator next_it = it + 1;
if ((next_it != end) && (*next_it == ':'))
{
query_ += ':';
++it;
}
}
}
break;
}
}
if (state == in_name)
{
names_.push_back(name);
std::ostringstream ss;
ss << '$' << position++;
query_ += ss.str();
}
#endif // SOCI_POSTGRESQL_NOBINDBYNAME
#ifndef SOCI_POSTGRESQL_NOPREPARE
if (stType == st_repeatable_query)
{
statementName_ = session_.get_next_statement_name();
PGresult * res = PQprepare(session_.conn_, statementName_.c_str(),
query_.c_str(), static_cast<int>(names_.size()), NULL);
if (res == NULL)
{
throw soci_error("Cannot prepare statement.");
}
ExecStatusType status = PQresultStatus(res);
if (status != PGRES_COMMAND_OK)
{
throw_postgresql_soci_error(res);
}
PQclear(res);
}
stType_ = stType;
#endif // SOCI_POSTGRESQL_NOPREPARE
}
uint128::uint128(const std::string &sz)
:hi(0), lo(0)
{
// do we have at least one character?
if(!sz.empty()) {
// make some reasonable assumptions
int radix = 10;
bool minus = false;
std::string::const_iterator i = sz.begin();
// check for minus sign, i suppose technically this should only apply
// to base 10, but who says that -0x1 should be invalid?
if(*i == '-') {
++i;
minus = true;
}
// check if there is radix changing prefix (0 or 0x)
if(i != sz.end()) {
if(*i == '0') {
radix = 8;
++i;
if(i != sz.end()) {
if(*i == 'x') {
radix = 16;
++i;
}
}
}
while(i != sz.end()) {
unsigned int n = 0;
const char ch = *i;
if(ch >= 'A' && ch <= 'Z') {
if(((ch - 'A') + 10) < radix) {
n = (ch - 'A') + 10;
} else {
break;
}
} else if(ch >= 'a' && ch <= 'z') {
if(((ch - 'a') + 10) < radix) {
n = (ch - 'a') + 10;
} else {
break;
}
} else if(ch >= '0' && ch <= '9') {
if((ch - '0') < radix) {
n = (ch - '0');
} else {
break;
}
} else {
/* completely invalid character */
break;
}
(*this) *= radix;
(*this) += n;
++i;
}
}
// if this was a negative number, do that two's compliment madness :-P
if(minus) {
*this = -*this;
}
}
}
void Signature::setOptionsSignature( std::string fp )
{
zeroStamp_ = true; //only matters if timestamp option is set
std::string::iterator itr;
for( itr = fp.begin(); itr != fp.end(); ++itr )
{
switch( tolower(*itr) )
{
case 'n': //NOOP
tcpOptions_.push_back( TCPOption::NO_OPERATION );
break;
case 'e': //EOL
tcpOptions_.push_back( TCPOption::END_OF_LIST );
//TODO: might want to check if we are really at the end of list?
break;
case 's': //SACKOK
tcpOptions_.push_back( TCPOption::SACK_PERMITTED );
break;
case 't': //TIMESTAMP
tcpOptions_.push_back( TCPOption::TIME_STAMP_OPTION );
if( *(itr + 1) != '0' )
zeroStamp_ = false;
break;
case 'w': //window Scale
tcpOptions_.push_back( TCPOption::WINDOW_SCALE );
if( *(itr + 1) == '*' ) //Wildcard
{
wsc_ = 1;
wscMod_ = MOD_CONST;
}
else if ( *(itr + 1) == '%' )
{
wscMod_ = MOD_CONST;
wsc_ = ss_atoi<uint32_t>( fp.substr( itr+2 - fp.begin() ) );
}
else
{
wsc_ = ss_atoi<uint32_t>( fp.substr( itr+2 - fp.begin() ) );
}
break;
case 'm': //Max Segment Size
tcpOptions_.push_back( TCPOption::MAXIMUM_SEGMENT_SIZE );
if( *(itr + 1) == '*' ) //Wildcard
{
mss_ = 1;
mssMod_ = MOD_CONST;
}
else if ( *(itr + 1) == '%' )
{
mssMod_ = MOD_CONST;
mss_ = ss_atoi<uint32_t>( fp.substr( itr+2 - fp.begin() ) );
}
else
{
mss_ = ss_atoi<uint32_t>( fp.substr( itr+2 - fp.begin() ) );
}
break;
case '?': //Unknown (not really just not one of the ones we look at
tcpOptions_.push_back( static_cast<uint8_t>( ss_atoi<uint16_t>( fp.substr( itr+1 - fp.begin() ) ) ) );
break;
default:
throw std::runtime_error( "Unknown TCP option in config" );
};
}
}
/// Make a string lowercase
std::string ToLower(std::string str) {
std::transform(str.begin(), str.end(), str.begin(), ::tolower);
return str;
}
void StringExtend::ToLower (std::string& source)
{
std::transform (source.begin (), source.end (), source.begin (), ::toupper);
}
/// Make a string uppercase
std::string ToUpper(std::string str) {
std::transform(str.begin(), str.end(), str.begin(), ::toupper);
return str;
}
inline void SaveHttpLogToFile(const std::string& url, const std::string& errMsg)
{
SaveHttpLogToFile(url, std::vector<char>(errMsg.begin(), errMsg.end()));
}
bool persist_file_context::clear_var(const std::string &global, bool immediate)
{
config bak;
config bactive;
if (immediate) {
bak = cfg_;
config *node = get_node(bak, namespace_);
if (node)
bactive = node->child_or_add("variables");
load();
}
config *active = get_node(cfg_, namespace_);
if (active == NULL)
return false;
bool ret = active->has_child("variables");
if (ret) {
config &cfg = active->child("variables");
bool exists = cfg.has_attribute(global);
if (!exists) {
if (cfg.has_child(global)) {
exists = true;
std::string::const_iterator index_start = std::find(global.begin(),global.end(),'[');
if (index_start != global.end())
{
const std::string::const_iterator index_end = std::find(global.begin(),global.end(),']');
const std::string index_str(index_start+1,index_end);
size_t index = static_cast<size_t>(lexical_cast_default<int>(index_str));
cfg.remove_child(global,index);
if (immediate) bactive.remove_child(global,index);
} else {
cfg.clear_children(global);
if (immediate) bactive.clear_children(global);
}
}
}
if (exists) {
cfg.remove_attribute(global);
if (immediate) bactive.remove_attribute(global);
if (cfg.empty()) {
active->clear_children("variables");
active->remove_attribute("variables");
name_space working = namespace_;
while ((active->empty()) && (!working.lineage_.empty())) {
name_space prev = working.prev();
active = get_node(cfg_, prev);
active->clear_children(working.node_);
if (active->has_child("variables") && active->child("variables").empty()) {
active->clear_children("variables");
active->remove_attribute("variables");
}
working = prev;
}
}
if (!in_transaction_)
ret = save_context();
else if (immediate) {
ret = save_context();
cfg_ = bak;
active = get_node(cfg_, namespace_);
if (active != NULL) {
active->clear_children("variables");
active->remove_attribute("variables");
if (!bactive.empty())
active->add_child("variables",bactive);
}
} else {
ret = true;
}
} else {
if (immediate) {
cfg_ = bak;
config *active = get_node(cfg_, namespace_);
if (active != NULL) {
active->clear_children("variables");
active->remove_attribute("variables");
if (!bactive.empty())
active->add_child("variables",bactive);
}
}
ret = exists;
}
}
// TODO: figure out when this is the case and adjust the next loop
// condition accordingly. -- shadowm
assert(active);
while (active && active->empty() && !namespace_.lineage_.empty()) {
name_space prev = namespace_.prev();
active = get_node(cfg_, prev);
if (active == NULL) {
break;
}
active->clear_children(namespace_.node_);
if (active->has_child("variables") && active->child("variables").empty()) {
active->clear_children("variables");
active->remove_attribute("variables");
}
namespace_ = prev;
}
return ret;
}