ssize_t getdelim (S *s, size_t *n, int d, FILE *f){ //target, current capacity, delimiter, file
#if 0
// this code is MSVC runtime version specific
char *q; I w=0;
if (!s) {errno = EINVAL; goto error;}
if (f->_cnt <= 0) {
if (expander(s, 1)) goto error;
(*s)[0] = '\0'; R *n=-1;
}
while ((q = memchr(f->_ptr, d, f->_cnt)) == NULL) {
if (appender(s, &w, (S) f->_ptr, f->_cnt)) goto error;
goto done; /* hit EOF */
}
q++; /* snarf the delimiter, too */
if (appender(s, &w, (S) f->_ptr, q - f->_ptr)) goto error;
f->_cnt -= q - f->_ptr; f->_ptr = q;
#endif
I w=0;
if (!s) {errno = EINVAL; goto error;}
for(;;) {
C c=fgetc(f);
if (EOF == c) R -1;
if (appender(s, &w, (S)&c, 1)) goto error;
if (d==c) break;
}
(*s)[w] = '\0'; R *n=w;
error: R *n=-1;
}
static void initLogSystem()
{
log4cplus::initialize();
// log to daily rolling log file
if (_LogFlags & LOG_TO_FILE)
{
// make sure path "Data/logs" exists
filesystem::wpath p = _DataPath / L"logs";
system::error_code ec;
filesystem::create_directories(p, ec); // ignore this error
log4cplus::SharedAppenderPtr appender(
new log4cplus::DailyRollingFileAppender((p / L"zzlab.log").wstring()));
appender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::TTCCLayout()));
log4cplus::Logger::getRoot().addAppender(appender);
}
// log to Win32 debug
if (_LogFlags & LOG_TO_WIN32DEBUG)
{
log4cplus::SharedAppenderPtr appender(new log4cplus::Win32DebugAppender());
appender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::TTCCLayout()));
log4cplus::Logger::getRoot().addAppender(appender);
}
// log to console
if (_LogFlags & LOG_TO_CONSOLE)
{
log4cplus::SharedAppenderPtr appender(new log4cplus::ConsoleAppender());
appender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::TTCCLayout()));
log4cplus::Logger::getRoot().addAppender(appender);
}
}
void Channel::SetOwner(ObjectGuid const& guid, bool exclaim)
{
if (!_ownerGuid.IsEmpty())
{
// [] will re-add player after it possible removed
auto itr = _playersStore.find(_ownerGuid);
if (itr != _playersStore.end())
itr->second.SetOwner(false);
}
_ownerGuid = guid;
if (!_ownerGuid.IsEmpty())
{
uint8 oldFlag = GetPlayerFlags(_ownerGuid);
auto itr = _playersStore.find(_ownerGuid);
if (itr == _playersStore.end())
return;
itr->second.SetModerator(true);
itr->second.SetOwner(true);
ModeChangeAppend appender(_ownerGuid, oldFlag, GetPlayerFlags(_ownerGuid));
ChannelNameBuilder<ModeChangeAppend> builder(this, appender);
SendToAll(builder);
if (exclaim)
{
OwnerChangedAppend appender(_ownerGuid);
ChannelNameBuilder<OwnerChangedAppend> builder(this, appender);
SendToAll(builder);
}
UpdateChannelInDB();
}
}
WebWatch::SiteItemGroup & CSiteGroupsTree::BuildTree(WebWatch::SiteItemGroup & group)
{
SetRedraw(FALSE);
DeleteAllItems();
m_group2item.clear();
HTREEITEM root = InsertGroupItem(group);
WebWatch::SiteItemGroup *defaultGroup = 0;
WebWatch::SiteItemGroup::GroupIterator it = group.GetGroupsBegin();
WebWatch::SiteItemGroup::GroupIterator end = group.GetGroupsEnd();
GroupAppender appender(*this, root);
while (it != end) {
WebWatch::SiteItemGroup *subgroup = *it;
appender(subgroup);
if (defaultGroup == 0 && subgroup->GetName() == "Default")
defaultGroup = subgroup;
++it;
}
SetRedraw();
if (defaultGroup == 0)
defaultGroup = &group;
return *defaultGroup;
}
void Channel::Invite(Player const* player, std::string const& newname)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
Player* newp = ObjectAccessor::FindConnectedPlayerByName(newname);
if (!newp || !newp->isGMVisible())
{
PlayerNotFoundAppend appender(newname);
ChannelNameBuilder<PlayerNotFoundAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (IsBanned(newp->GetGUID()))
{
PlayerInviteBannedAppend appender(newname);
ChannelNameBuilder<PlayerInviteBannedAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (newp->GetTeam() != player->GetTeam() &&
(!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL)))
{
InviteWrongFactionAppend appender;
ChannelNameBuilder<InviteWrongFactionAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (IsOn(newp->GetGUID()))
{
PlayerAlreadyMemberAppend appender(newp->GetGUID());
ChannelNameBuilder<PlayerAlreadyMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (!newp->GetSocial()->HasIgnore(guid))
{
InviteAppend appender(guid);
ChannelNameBuilder<InviteAppend> builder(this, appender);
SendToOne(builder, newp->GetGUID());
}
PlayerInvitedAppend appender(newp->GetName());
ChannelNameBuilder<PlayerInvitedAppend> builder(this, appender);
SendToOne(builder, guid);
}
/**
* Statically initialize the log4cxx library.
*/
void configureLogging(const std::string logString, const log4cxx::LevelPtr level) {
log4cxx::LayoutPtr layout(new log4cxx::PatternLayout(logString));
log4cxx::AppenderPtr appender(new log4cxx::ConsoleAppender(layout));
log4cxx::BasicConfigurator::configure(appender);
log4cxx::LoggerPtr rootlogger = log4cxx::Logger::getRootLogger();
rootlogger->setLevel(level);
}
void Channel::Password(Player const* player, std::string const& pass)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
PlayerInfo& info = _playersStore.at(guid);
if (!info.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
_channelPassword = pass;
PasswordChangedAppend appender(guid);
ChannelNameBuilder<PasswordChangedAppend> builder(this, appender);
SendToAll(builder);
UpdateChannelInDB();
}
/**
Intialize root logger.
@param pattern Log pattern.
@param immediateFlush When it is set true, output stream will be flushed
after each appended event.
@return Logger instance.
*/
static Logger InitLogger(tstring pattern = tstring(LOG_PATTERN),
bool immediateFlush = LOG_DEFAULT_IMMEDIATE_FLUSH)
{
log4cplus::initialize();
log4cplus::SharedAppenderPtr appender(
new log4cplus::ConsoleAppender(false, immediateFlush));
appender->setName(TEXT("default"));
appender->setLayout(std::auto_ptr<log4cplus::Layout>(
new log4cplus::PatternLayout(pattern)));
Logger logger = log4cplus::Logger::getRoot();
logger.addAppender(appender);
#if defined(WIN32) // && defined(_DEBUG)
log4cplus::SharedAppenderPtr _appender(new log4cplus::Win32DebugAppender);
_appender->setName(TEXT("win32"));
_appender->setLayout(std::auto_ptr<log4cplus::PatternLayout>(
new log4cplus::PatternLayout(pattern)));
logger.addAppender(_appender);
#endif
#ifdef _DEBUG
logger.setLogLevel(LEVEL_DEBUG);
#else
logger.setLogLevel(LEVEL_INFO);
#endif
return logger;
}
int HarnessTestExecutor :: createLogger (void)
{
assert (_ie.log_file.length () > 0);
bfs::remove (_ie.log_file);
log4cxx :: LayoutPtr layout (new log4cxx :: PatternLayout ("%d %p %x - %m%n"));
log4cxx :: FileAppenderPtr appender (new log4cxx :: FileAppender (layout, _ie.log_file, true));
_logger = log4cxx :: Logger :: getLogger (_ie.logger_name);
_logger->addAppender (appender);
_executorTag = LOGGER_TAG_HARNESSEXECUTOR;
_executorTag += '[' + _ie.logger_name + ']';
LOGGER_PUSH_NDCTAG (_executorTag);
_loggerEnabled = true;
LOG4CXX_INFO (_logger, "logger SYSTEM ENABLED");
switch (_ie.debugLevel)
{
case DEBUGLEVEL_FATAL : _logger->setLevel (log4cxx :: Level :: getFatal ()); break;
case DEBUGLEVEL_ERROR : _logger->setLevel (log4cxx :: Level :: getError ()); break;
case DEBUGLEVEL_WARN : _logger->setLevel (log4cxx :: Level :: getWarn ()); break;
case DEBUGLEVEL_INFO : _logger->setLevel (log4cxx :: Level :: getInfo ()); break;
case DEBUGLEVEL_DEBUG : _logger->setLevel (log4cxx :: Level :: getDebug ()); break;
case DEBUGLEVEL_TRACE : _logger->setLevel (log4cxx :: Level :: getTrace ()); break;
default : return FAILURE;
}
return SUCCESS;
}
bool csv_parser::next_value( zstring *value, bool *eol, bool *quoted ) const {
ztd::string_appender<zstring,128> appender( value );
char c;
bool in_quote = false;
bool is_quoted = false;
value->clear();
while ( is_->get( c ) ) {
if ( in_quote ) {
if ( quote_esc_ == quote_ ) { // ""
if ( c == quote_ ) {
if ( !peek( *is_, c ) )
break;
if ( c != quote_ ) {
in_quote = false;
continue;
}
is_->get();
}
} else { // \"
if ( c == quote_ ) {
in_quote = false;
continue;
}
if ( c == quote_esc_ && !is_->get( c ) )
break;
}
} else {
if ( c == quote_ ) {
in_quote = is_quoted = true;
continue;
}
if ( c == sep_ ) {
*eol = false;
goto return_true;
}
switch ( c ) {
case '\r':
if ( peek( *is_, c ) && c == '\n' )
is_->get();
// no break;
case '\n':
*eol = true;
goto return_true;
} // switch
} // else
appender += c;
} // while
appender.flush();
if ( value->empty() )
return false;
*eol = true;
return_true:
if ( quoted )
*quoted = is_quoted;
return true;
}
// ------------------------------------------------------------------
void msvc_debugger_listener::report_leak(
const Dereferee::allocation_info& leak)
{
fprintf(memory_log, " <leak address=\"%p\"", leak.address());
if(leak.is_array())
fprintf(memory_log, " is-array=\"true\"");
if(leak.type_name())
{
if(leak.is_array())
fprintf(memory_log, " type=\"%s[%lu]\"", leak.type_name(),
(unsigned long)leak.array_size());
else
fprintf(memory_log, " type=\"%s\"", leak.type_name());
}
fprintf(memory_log, " size=\"%lu\">\n",
(unsigned long)leak.block_size());
CxxTest::FileAppender appender(memory_log);
CxxTest::__append_backtrace_xml(leak.backtrace(), true, appender);
fprintf(memory_log, " </leak>\n");
}
void NamedValueSet::setFromXmlAttributes (const XmlElement& xml)
{
clear();
LinkedListPointer<NamedValue>::Appender appender (values);
const int numAtts = xml.getNumAttributes(); // xxx inefficient - should write an att iterator..
for (int i = 0; i < numAtts; ++i)
{
const String& name = xml.getAttributeName (i);
const String& value = xml.getAttributeValue (i);
if (name.startsWith ("base64:"))
{
MemoryBlock mb;
if (mb.fromBase64Encoding (value))
{
appender.append (new NamedValue (name.substring (7), var (mb)));
continue;
}
}
appender.append (new NamedValue (name, var (value)));
}
}
UnicodeString &
DigitFormatter::formatDigits(
const uint8_t *digits,
int32_t count,
const IntDigitCountRange &range,
int32_t intField,
FieldPositionHandler &handler,
UnicodeString &appendTo) const {
int32_t i = range.pin(count) - 1;
int32_t begin = appendTo.length();
// Always emit '0' as placeholder for empty string.
if (i == -1) {
appendTo.append(fLocalizedDigits[0]);
handler.addAttribute(intField, begin, appendTo.length());
return appendTo;
}
{
UnicodeStringAppender appender(appendTo);
for (; i >= count; --i) {
appender.append(fLocalizedDigits[0]);
}
for (; i >= 0; --i) {
appender.append(fLocalizedDigits[digits[i]]);
}
}
handler.addAttribute(intField, begin, appendTo.length());
return appendTo;
}
/**
Configurate specified logger.
@param name Logger name.
@param logLevel Log level.
@param logFile Log file name, empty if console.
@param immediateFlush When it is set true, output stream will be flushed
after each appended event.
@return Has the logger been configurated before?
*/
static bool ConfigLogger(const tstring& name = TEXT(""),
const tstring& logLevel = TEXT("INFO"),
const tstring& logFile = TEXT(""),
bool immediateFlush = LOG_DEFAULT_IMMEDIATE_FLUSH)
{
Logger logger = GetLogger(name);
bool existed = false;
if(name.empty()) // Root.
{
if(logger.getAppender(TEXT("default")))
existed = true;
}
if(logger.getAppender(TEXT("config")))
existed = true;
if(logger.getAppender(TEXT("default")))
logger.removeAppender(TEXT("default"));
if(logger.getAppender(TEXT("config")))
logger.removeAppender(TEXT("config"));
if(!logFile.empty())
{
log4cplus::SharedAppenderPtr appender(new log4cplus::FileAppender(
logFile, std::ios::app, immediateFlush));
appender->setName(TEXT("config"));
appender->setLayout(std::auto_ptr<log4cplus::Layout>(
new log4cplus::PatternLayout(LOG_PATTERN)));
logger.addAppender(appender);
}
else
{
log4cplus::SharedAppenderPtr appender(
new log4cplus::ConsoleAppender(false, immediateFlush));
appender->setName(TEXT("config"));
appender->setLayout(std::auto_ptr<log4cplus::Layout>(
new log4cplus::PatternLayout(LOG_PATTERN)));
logger.addAppender(appender);
}
log4cplus::LogLevelManager& llm = log4cplus::getLogLevelManager();
logger.setLogLevel(llm.fromString(logLevel));
return existed;
}
MojErr MojLogEngine::createAppender(const MojObject& conf, const MojChar* name, MojAutoPtr<MojLogAppender>& appenderOut)
{
MojString type;
MojErr err = conf.getRequired(TypeKey, type);
MojErrCheck(err);
// TODO: use some sort of factory registry to do this
if (type == _T("file")) {
MojString path;
err = conf.getRequired(PathKey, path);
MojErrCheck(err);
MojAutoPtr<MojFileAppender> appender(new MojFileAppender());
MojAllocCheck(appender.get());
err = appender->open(path.data());
MojErrCheck(err);
appenderOut = appender;
} else if (type == _T("stderr")) {
MojAutoPtr<MojFileAppender> appender(new MojFileAppender());
MojAllocCheck(appender.get());
appender->open(MojStdErrFile);
appenderOut = appender;
} else if (type == _T("stdout")) {
MojAutoPtr<MojFileAppender> appender(new MojFileAppender());
MojAllocCheck(appender.get());
appender->open(MojStdOutFile);
appenderOut = appender;
}
#ifdef MOJ_USE_SYSLOG
else if (type == _T("syslog")) {
MojAutoPtr<MojSyslogAppender> appender(new MojSyslogAppender());
MojAllocCheck(appender.get());
appender->open(name);
appenderOut = appender;
}
#endif // MOJ_USE_SYSLOG
#ifdef MOJ_USE_PMLOG
else if (type == _T("pmlog")) {
MojAutoPtr<MojPmLogAppender> appender(new MojPmLogAppender());
MojAllocCheck(appender.get());
appenderOut = appender;
}
#endif // MOJ_USE_PMLOG
else {
MojErrThrowMsg(MojErrLogAppenderNotFound, _T("log: appender not found '%s'"), type.data());
}
return MojErrNone;
}
I getdelim(S *s,size_t*n, I d, FILE *f)//target, current capacity, delimiter, file
{
unsigned char *q;
I w=0;
flockfile(f);
//ORIENT(f,-1) //is this dangerous?
if (!s) {errno = EINVAL; goto error;}
if (f->_r <= 0 && __srefill(f))
{
/* If f is at EOF already, we just need space for the NUL. */
if (__sferror(f) || expander(s, 1)) goto error;
funlockfile(f);
(*s)[0] = '\0';
R *n=-1;
}
while ((q = memchr(f->_p, d, f->_r)) == NULL)
{
if (appender(s, &w, (S) f->_p, f->_r)) goto error;
if (__srefill(f))
{
if (__sferror(f)) goto error;
goto done; /* hit EOF */
}
}
q++; /* snarf the delimiter, too */
if (appender(s, &w, (S) f->_p, q - f->_p)) goto error;
f->_r -= q - f->_p;
f->_p = q;
done:
/* Invariant: *s has space for at least w+1 bytes. */
(*s)[w] = '\0';
funlockfile(f);
R *n=w;
error:
f->_flags |= __SERR;
funlockfile(f);
R *n=-1;
}
void NamedValueSet::setFromXmlAttributes (const XmlElement& xml)
{
clear();
LinkedListPointer<NamedValue>::Appender appender (values);
const int numAtts = xml.getNumAttributes(); // xxx inefficient - should write an att iterator..
for (int i = 0; i < numAtts; ++i)
appender.append (new NamedValue (xml.getAttributeName (i), var (xml.getAttributeValue (i))));
}
void
DigitAffix::append(const UChar *value, int32_t charCount, int32_t fieldId) {
fAffix.append(value, charCount);
{
UnicodeStringAppender appender(fAnnotations);
for (int32_t i = 0; i < charCount; ++i) {
appender.append((UChar) fieldId);
}
}
}
uint32_t JSONProtocolWriterCommon::writeJSONIntInternal(int64_t num) {
WrappedIOBufQueueAppender appender(out_);
if (!context.empty() && context.back().type == ContextType::MAP &&
context.back().meta % 2 == 1) {
folly::toAppend('"', num, '"', &appender);
} else {
folly::toAppend(num, &appender);
}
return appender.size();
}
void
DigitAffix::append(const UnicodeString &value, int32_t fieldId) {
fAffix.append(value);
{
UnicodeStringAppender appender(fAnnotations);
int32_t len = value.length();
for (int32_t i = 0; i < len; ++i) {
appender.append((UChar) fieldId);
}
}
}
RoopList WriteParams::execute(RoopMachine &machine, RoopList arguments) {
std::string filename = arguments[0].resultString;
std::ofstream appender(filename.c_str(), std::ios::out | std::ios::app);
for (int i=1; i<arguments.size(); i++) {
appender << arguments[i].resultString << " ";
}
appender << std::endl;
appender.close();
return arguments;
}
std::unique_ptr<folly::IOBuf> toBserIOBuf(folly::dynamic const& dyn,
const serialization_opts& opts) {
IOBufQueue q(IOBufQueue::cacheChainLength());
uint8_t hdrbuf[sizeof(kMagic) + 1 + sizeof(int64_t)];
// Reserve some headroom for the overall PDU size; we'll fill this in
// after we've serialized the data and know the length
auto firstbuf = IOBuf::create(opts.growth_increment);
firstbuf->advance(sizeof(hdrbuf));
q.append(std::move(firstbuf));
// encode the value
QueueAppender appender(&q, opts.growth_increment);
bserEncode(dyn, appender, opts);
// compute the length
auto len = q.chainLength();
if (len > std::numeric_limits<int64_t>::max()) {
throw std::range_error(folly::to<std::string>(
"serialized data size ", len, " is too large to represent as BSER"));
}
// This is a bit verbose, but it computes a header that is appropriate
// to the size of the serialized data
memcpy(hdrbuf, kMagic, sizeof(kMagic));
size_t hdrlen = sizeof(kMagic) + 1;
auto magicptr = hdrbuf + sizeof(kMagic);
auto lenptr = hdrbuf + hdrlen;
if (len > std::numeric_limits<int32_t>::max()) {
*magicptr = (int8_t)BserType::Int64;
*(int64_t*)lenptr = (int64_t)len;
hdrlen += sizeof(int64_t);
} else if (len > std::numeric_limits<int16_t>::max()) {
*magicptr = (int8_t)BserType::Int32;
*(int32_t*)lenptr = (int32_t)len;
hdrlen += sizeof(int32_t);
} else if (len > std::numeric_limits<int8_t>::max()) {
*magicptr = (int8_t)BserType::Int16;
*(int16_t*)lenptr = (int16_t)len;
hdrlen += sizeof(int16_t);
} else {
*magicptr = (int8_t)BserType::Int8;
*(int8_t*)lenptr = (int8_t)len;
hdrlen += sizeof(int8_t);
}
// and place the data in the headroom
q.prepend(hdrbuf, hdrlen);
return q.move();
}
void Channel::UnBan(Player const* player, std::string const& badname)
{
ObjectGuid const& good = player->GetGUID();
if (!IsOn(good))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
PlayerInfo& info = _playersStore.at(good);
if (!info.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
Player* bad = ObjectAccessor::FindConnectedPlayerByName(badname);
ObjectGuid victim = bad ? bad->GetGUID() : ObjectGuid::Empty;
if (victim.IsEmpty() || !IsBanned(victim))
{
PlayerNotFoundAppend appender(badname);
ChannelNameBuilder<PlayerNotFoundAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
_bannedStore.erase(victim);
PlayerUnbannedAppend appender(good, victim);
ChannelNameBuilder<PlayerUnbannedAppend> builder(this, appender);
SendToAll(builder);
UpdateChannelInDB();
}
void Channel::Announce(Player const* player)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
PlayerInfo const& playerInfo = _playersStore.at(guid);
if (!playerInfo.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
_announceEnabled = !_announceEnabled;
WorldPackets::Channel::ChannelNotify notify;
if (_announceEnabled)
{
AnnouncementsOnAppend appender(guid);
ChannelNameBuilder<AnnouncementsOnAppend> builder(this, appender);
SendToAll(builder);
}
else
{
AnnouncementsOffAppend appender(guid);
ChannelNameBuilder<AnnouncementsOffAppend> builder(this, appender);
SendToAll(builder);
}
UpdateChannelInDB();
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
PlayerInfo& info = _playersStore.at(guid);
if (!info.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (guid == _ownerGuid && p2n == player->GetName() && mod)
return;
Player* newp = ObjectAccessor::FindConnectedPlayerByName(p2n);
ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
if (victim.IsEmpty() || !IsOn(victim) ||
(player->GetTeam() != newp->GetTeam() &&
(!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
{
PlayerNotFoundAppend appender(p2n);
ChannelNameBuilder<PlayerNotFoundAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (_ownerGuid == victim && _ownerGuid != guid)
{
NotOwnerAppend appender;
ChannelNameBuilder<NotOwnerAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void CSiteGroupsTree::OnSiteGroupImportChildGroup()
{
ASSERT(m_actionGroup);
CWnd *parent = GetParent();
ASSERT(parent);
CFileDialog dlg(TRUE, DefaultExtension, 0, OFN_NOCHANGEDIR | OFN_FILEMUSTEXIST, DefaultFilter, parent);
char currentDir[_MAX_PATH];
dlg.m_ofn.lpstrInitialDir = _getcwd(currentDir, _MAX_PATH);
if (dlg.DoModal() != IDOK)
return;
CString filename = dlg.GetPathName();
try {
WebWatch::SiteItemGroup & importedGroup = WebWatch::Store::Instance().ImportGroup(*m_actionGroup, filename);
GroupAppender appender(*this, GetItemFromGroup(*m_actionGroup));
appender(&importedGroup);
}
catch(const WebWatch::StoreError & ex) {
parent->MessageBox(ex.what(), "Failure", MB_OK | MB_ICONERROR);
return;
}
UpdateTree();
WebWatch::SiteItemGroup & selectedGroup = GetGroupFromItem(GetSelectedItem());
RefreshSiteList(selectedGroup);
std::string message("Group(s) in file '");
message += dlg.GetFileName();
message += "' imported successfully under group '";
message += m_actionGroup->GetName();
message += '\'';
parent->MessageBox(message.c_str(), "Success", MB_OK | MB_ICONINFORMATION);
}
void Channel::SendWhoOwner(Player const* player)
{
ObjectGuid const& guid = player->GetGUID();
if (IsOn(guid))
{
ChannelOwnerAppend appender(this, _ownerGuid);
ChannelNameBuilder<ChannelOwnerAppend> builder(this, appender);
SendToOne(builder, guid);
}
else
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
}
}
/* Initialize log4dcxx automatically when the library is loaded. */
WOO__ATTRIBUTE__CONSTRUCTOR void initLog4cxx() {
#ifdef LOG4CXX_TRACE
log4cxx::LevelPtr debugLevel=log4cxx::Level::getDebug(), infoLevel=log4cxx::Level::getInfo(), warnLevel=log4cxx::Level::getWarn();
// LOG4CXX_STR: http://old.nabble.com/Link-error-when-using-Layout-on-MS-Windows-td20906802.html
log4cxx::LayoutPtr layout(new log4cxx::PatternLayout(LOG4CXX_STR("%-5r %-5p %-10c %m%n")));
log4cxx::AppenderPtr appender(new log4cxx::ConsoleAppender(layout));
log4cxx::LoggerPtr localLogger=log4cxx::Logger::getLogger("woo");
localLogger->addAppender(appender);
#else // log4cxx 0.9
log4cxx::LevelPtr debugLevel=log4cxx::Level::DEBUG, infoLevel=log4cxx::Level::INFO, warnLevel=log4cxx::Level::WARN;
log4cxx::BasicConfigurator::configure();
log4cxx::LoggerPtr localLogger=log4cxx::Logger::getLogger("woo");
#endif
localLogger->setLevel(getenv("WOO_DEBUG")?debugLevel:warnLevel);
LOG4CXX_DEBUG(localLogger,"Log4cxx initialized.");
}
void Channel::SetMute(ObjectGuid const& guid, bool set)
{
if (!IsOn(guid))
return;
PlayerInfo& playerInfo = _playersStore.at(guid);
if (playerInfo.IsMuted() != set)
{
uint8 oldFlag = playerInfo.GetFlags();
playerInfo.SetMuted(set);
ModeChangeAppend appender(guid, oldFlag, playerInfo.GetFlags());
ChannelNameBuilder<ModeChangeAppend> builder(this, appender);
SendToAll(builder);
}
}
UnicodeString &
AffixPattern::toString(UnicodeString &appendTo) const {
AffixPatternIterator iter;
iterator(iter);
UnicodeStringAppender appender(appendTo);
UnicodeString literal;
while (iter.nextToken()) {
switch (iter.getTokenType()) {
case kLiteral:
escapeApostropheInLiteral(iter.getLiteral(literal), appender);
break;
case kPercent:
appender.append((UChar) 0x27);
appender.append((UChar) 0x25);
break;
case kPerMill:
appender.append((UChar) 0x27);
appender.append((UChar) 0x2030);
break;
case kCurrency:
{
appender.append((UChar) 0x27);
int32_t cl = iter.getTokenLength();
for (int32_t i = 0; i < cl; ++i) {
appender.append((UChar) 0xA4);
}
}
break;
case kNegative:
appender.append((UChar) 0x27);
appender.append((UChar) 0x2D);
break;
case kPositive:
appender.append((UChar) 0x27);
appender.append((UChar) 0x2B);
break;
default:
U_ASSERT(FALSE);
break;
}
}
return appendTo;
}
