bool MySQL::CloseConn(const Variant& link_identifier) {
auto mySQL = Get(link_identifier);
if (mySQL && !mySQL->isPersistent()) {
mySQL->close();
}
return true;
}
void LootkitObjectImplementation::createItem() {
for (int i = 0; i<comps.size(); ++i) {
if (components.get(comps.get(i)) == 0) {
return; // Still missing pieces
}
}
ManagedReference<CreatureObject*> player = getPlayer();
if (player != NULL) {
player->sendSystemMessage("@loot_kit:new_item_created");
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
ZoneServer* zoneServer = server->getZoneServer();
ManagedReference<SceneObject*> rewardObject = zoneServer->createObject(reward.get(System::random(reward.size()-1)), 2);
Locker clocker(inventory, player);
rewardObject->sendTo(player, true);
if (inventory->transferObject(rewardObject, -1, true)) {
//getParent()->removeObject(_this, true);
destroyObjectFromWorld(true);
if (isPersistent())
destroyObjectFromDatabase(true);
}
}
}
ibrcommon::Timer::time_t Registration::getExpireTime() const
{
if(!isPersistent()) throw NotPersistentException("Registration is not persistent.");
return _expiry;
}
vector<TeamId> CollectiveTeams::getActiveNonPersistent(const Creature* c) const {
vector<TeamId> ret;
for (TeamId t : getContaining(c))
if (isActive(t) && !isPersistent(t))
ret.push_back(t);
return ret;
}
void ResourceDeedImplementation::destroyDeed() {
if (parent.get() != NULL) {
destroyObjectFromWorld(true);
}
if (isPersistent())
destroyObjectFromDatabase(true);
generated = true;
}
void KURLBarItem::setApplicationLocal(bool local)
{
if(!local && !isPersistent())
{
kdWarning() << "KURLBar: dynamic (non-persistent) items can not be global." << endl;
return;
}
m_appLocal = local;
}
bool MySQL::CloseConn(const Variant& link_identifier) {
auto mySQL = Get(link_identifier);
if (mySQL) {
if (!mySQL->isPersistent()) {
mySQL->close();
} else {
s_cur_num_persistent--;
}
}
return true;
}
void ResourceDeedImplementation::destroyDeed() {
if (parent.get() != NULL) {
/*getParent()->removeObject(_this.getReferenceUnsafeStaticCast(), true);
broadcastDestroy(_this.getReferenceUnsafeStaticCast(), false);*/
destroyObjectFromWorld(true);
}
if (isPersistent())
destroyObjectFromDatabase(true);
generated = true;
}
void AssignNameOverlay::viewportLeaveEvent(QObject* o, QEvent* e)
{
if (isPersistent() && m_widget->isVisible())
{
return;
}
// Do not hide when hovering the pop-up of the line edit.
if (d->isChildWidget(qApp->widgetAt(QCursor::pos()), assignNameWidget()))
{
return;
}
PersistentWidgetDelegateOverlay::viewportLeaveEvent(o, e);
}
Variant::operator v8::Local<v8::Value>() const
{
switch (type())
{
case VT_Undefined:
return v8::Undefined(isolate);
case VT_Null:
case VT_Type:
case VT_Persistent:
return v8::Null(isolate);
case VT_Boolean:
return m_Val.boolVal ? v8::True(isolate) : v8::False(isolate);
case VT_Integer:
return v8::Int32::New(isolate, m_Val.intVal);
case VT_Long:
return v8::Number::New(isolate, (double) m_Val.longVal);
case VT_Number:
return v8::Number::New(isolate, m_Val.dblVal);
case VT_Date:
return dateVal();
case VT_Object:
{
object_base *obj = (object_base *) m_Val.objVal;
if (obj == NULL)
break;
return obj->wrap();
}
case VT_JSValue:
if (isPersistent())
return v8::Local<v8::Value>::New(isolate, jsValEx());
else
return jsVal();
case VT_String:
{
std::string &str = strVal();
return v8::String::NewFromUtf8(isolate, str.c_str(),
v8::String::kNormalString,
(int) str.length());
}
}
return v8::Null(isolate);
}
void FireworkObjectImplementation::completeLaunch(CreatureObject* player, int removeDelay) {
ManagedReference<StaticObject*> launcherObject = (getZoneServer()->createObject(fireworkObject.hashCode(), 0)).castTo<StaticObject*>();
if (launcherObject == NULL)
return;
player->setPosture(CreaturePosture::CROUCHED);
player->doAnimation("manipulate_low");
float angle = player->getDirectionAngle();
if (angle > 360)
angle = angle - 360;
float distance = 2.0;
angle = 2 * M_PI * angle / 360;
int x = player->getPositionX() + sin(angle) * (distance);
int y = player->getPositionY() + cos(angle) * (distance);
int z = player->getZone()->getHeight(x, y);
Locker locker(launcherObject);
launcherObject->initializePosition(x, z, y);
player->getZone()->transferObject(launcherObject, -1, true);
if (getUseCount() > 1) {
decreaseUseCount();
} else {
destroyObjectFromWorld(true);
if (isPersistent())
destroyObjectFromDatabase(true);
}
Reference<FireworkRemoveEvent*> fireworkRemoveEvent = new FireworkRemoveEvent(player, launcherObject);
fireworkRemoveEvent->schedule(removeDelay * 1000);
}
/*
Checks if the Sym instance is of type non-terminal.
*
The function will return true for non-special non-terminals
*/
inline bool isNonterminal() const {
assert(!isPersistent());
return (id_ & kSmallTypeMask) == kNonterminal;
}
Packet* ManagedObjectAdapter::invokeMethod(uint32 methid, DistributedMethod* inv) {
Packet* resp = new MethodReturnMessage(0);
switch (methid) {
case 6:
lock(inv->getBooleanParameter());
break;
case 7:
lock((ManagedObject*) inv->getObjectParameter());
break;
case 8:
rlock(inv->getBooleanParameter());
break;
case 9:
wlock(inv->getBooleanParameter());
break;
case 10:
wlock((ManagedObject*) inv->getObjectParameter());
break;
case 11:
unlock(inv->getBooleanParameter());
break;
case 12:
runlock(inv->getBooleanParameter());
break;
case 13:
setLockName(inv->getAsciiParameter(_param0_setLockName__String_));
break;
case 14:
resp->insertBoolean(notifyDestroy());
break;
case 15:
writeObject(inv->getAsciiParameter(_param0_writeObject__String_));
break;
case 16:
readObject(inv->getAsciiParameter(_param0_readObject__String_));
break;
case 17:
initializeTransientMembers();
break;
case 18:
updateToDatabase();
break;
case 19:
queueUpdateToDatabaseTask();
break;
case 20:
clearUpdateToDatabaseTask();
break;
case 21:
resp->insertInt(getLastCRCSave());
break;
case 22:
setLastCRCSave(inv->getUnsignedIntParameter());
break;
case 23:
resp->insertBoolean(isPersistent());
break;
case 24:
resp->insertSignedInt(getPersistenceLevel());
break;
case 25:
setPersistent(inv->getSignedIntParameter());
break;
default:
return NULL;
}
return resp;
}
Variant &Variant::operator=(v8::Local<v8::Value> v)
{
clear();
if (v.IsEmpty() || v->IsUndefined())
set_type(VT_Undefined);
else if (v->IsNull())
set_type(VT_Null);
else if (v->IsDate())
{
set_type(VT_Date);
dateVal() = v;
}
else if (v->IsBoolean() || v->IsBooleanObject())
{
set_type(VT_Boolean);
m_Val.boolVal = v->BooleanValue();
}
else if (v->IsNumber() || v->IsNumberObject())
{
double n = v->NumberValue();
int64_t num = (int64_t) n;
if (n == (double) num)
{
if (num >= -2147483648ll && num <= 2147483647ll)
{
set_type(VT_Integer);
m_Val.intVal = (int32_t) num;
}
else
{
set_type(VT_Long);
m_Val.longVal = num;
}
}
else
{
set_type(VT_Number);
m_Val.dblVal = n;
}
}
else if (v->IsString() || v->IsStringObject())
{
v8::String::Utf8Value s(v);
std::string str(*s, s.length());
return operator=(str);
}
else
{
object_base *obj = object_base::getInstance(v);
if (obj)
return operator=(obj);
else
{
set_type(VT_JSValue);
if (isPersistent())
{
new (((v8::Persistent<v8::Value> *) m_Val.jsVal)) v8::Persistent<v8::Value>();
jsValEx().Reset(isolate, v);
}
else
new (((v8::Local<v8::Value> *) m_Val.jsVal)) v8::Local<v8::Value>(v);
return *this;
}
}
return *this;
}
/** @short Return true if this task has already done its job and is now merely listening for further updates */
bool SortTask::isJustUpdatingNow() const
{
return isPersistent() && m_firstCommandCompleted && !_aborted;
}
NCommand_(NCommand* o, const nstr& command, int mode)
: o_(o),
command_(command),
closeSignal_(15),
ifd_(-1),
ofd_(-1),
efd_(-1),
mode_(mode){
int ip[2];
int op[2];
int ep[2];
if(mode_ & NCommand::OutputWithError &&
(mode_ & NCommand::Output || mode_ & NCommand::Error)){
NERROR("OutputWithError mode cannot be combined with Output or "
"Error modes");
}
if(mode_ & NCommand::Input){
pipe(ip);
}
if(mode_ & NCommand::Output){
pipe(op);
}
if(mode_ & NCommand::Error){
pipe(ep);
}
if(mode_ & NCommand::OutputWithError){
pipe(op);
}
if(!isPersistent()){
_resourceManager->add(o_);
}
pid_ = fork();
if(pid_ < 0){
NERROR("failed to execute command: " + command);
}
if(pid_ == 0){
if(mode_ & NCommand::Input){
::close(ip[1]);
dup2(ip[0], 0);
::close(ip[0]);
}
if(mode_ & NCommand::Output){
::close(op[0]);
dup2(op[1], 1);
::close(op[1]);
}
if(mode_ & NCommand::Error){
::close(ep[0]);
dup2(ep[1], 2);
::close(ep[1]);
}
if(mode_ & NCommand::OutputWithError){
::close(op[0]);
dup2(op[1], 1);
dup2(op[1], 2);
::close(op[1]);
}
if(execl("/bin/bash", "bash", "-c", command.c_str(), NULL) < 0){
NERROR("failed to execute command: " + command);
}
}
else{
if(mode_ & NCommand::Input){
::close(ip[0]);
ifd_ = ip[1];
}
if(mode_ & NCommand::Output){
::close(op[1]);
ofd_ = op[0];
fcntl(ofd_, F_SETFL, O_NONBLOCK);
}
if(mode_ & NCommand::Error){
::close(ep[1]);
efd_ = ep[0];
fcntl(efd_, F_SETFL, O_NONBLOCK);
}
if(mode_ & NCommand::OutputWithError){
::close(op[1]);
ofd_ = op[0];
efd_ = op[0];
fcntl(ofd_, F_SETFL, O_NONBLOCK);
}
}
}
~NCommand_(){
if(!isPersistent()){
_resourceManager->remove(o_);
close(true);
}
}
inline void serialize(Archive& ar, const SymInt version) {
ar & id_;
assert(!isPersistent());
}
inline bool isSpecialTerminal() const {
assert(!isPersistent());
return id_ >= (SymInt)kSpecialTerminal && id_ < (SymInt)kEndSpecialTerminal;
}
/** \return is a lexical non-special terminal symbol - kTerminal or kPeristentTerminal
*/
inline bool isLexical() const {
assert(!isPersistent());
assert(((SymInt)(id_ + 1) > (SymInt)kTerminal)
== (id_ >= (SymInt)kBeginTerminal && id_ < (SymInt)kEndTerminal));
return (SymInt)(id_ + 1) > (SymInt)kTerminal;
}
bool Event::isRipe() const
{
return ((isPersistent() || isTriggered()) &&
(delay == 0.0 || assignTime <= model.getTime()));
}
void removePersistentBit() {
if (isPersistent())
id_ += (1u << 29);
}
