void reset() {
::reset();
set_open("door", 0);
set_locked("door", 1);
MJUNGLE "tomb20.c"->set_open("door", 0);
MJUNGLE "tomb20.c"->set_locked("door", 1);
}
/// \brief Release all threads waiting on this semaphore.
void set()
{
event_.store(true, boost::memory_order_release);
typename mutex_type::scoped_lock l(mtx_);
set_locked(l);
}
void reset() {
::reset();
set_open("door", 1);
set_locked("door", 0);
"/d/shadow/rooms/palace27.c"->set_open("door", 1);
"/d/shadow/rooms/palace27.c"->set_locked("door", 0);
}
int unlock_buffer(char *srvName,char *dirName,char *idBucket,BUCKET_T *buffer){
char lock_flag;
BUCKET_T header;
header = *buffer;
state = set_server(cluster,srvName,&ioctx);
if(state < 0){
fprintf(stderr,"[unlock_buffer/iceph.c] Servidor não localizado!\n");
return 1;
}
//seta o diretorio
state = set_directory(dirName,&ioctx);
if(state >= 0){
lock_flag = '0';
//altera o valor do flag no sa
state = write_object(ioctx,idBucket,&lock_flag,LOCK_FLAG_SIZE,0,0);
if(state >= 0){
//altera no buffer
*(header+LCKFLAG_OFFSET) = lock_flag;
//altera o parametro locked no buffer_pool
state = set_locked(idBucket,srvName,lock_flag);
}else
return 1; //retorna 1 pois nao conseguiu escrever no buffer
}else{
fprintf(stderr,"[unlock_buffer/iceph.c] Diretório não localizado!\n");
return 1;
}
return 0;
}
void create() {
::create();
set("short", "Room");
set("long", "Sample 7\nThe wall behind you cannot be moved from this side. "
+"Keep on moving. The door to the north is made out of wood. It "
+"is locked but the key hole is fused shut. You're going to have "
+"to break it down.");
set_exits(([ "north" : "/wizards/pyro/doors/sample10",
"southeast" : "/wizards/pyro/doors/sample6", ]));
cover_exit_with_door("southeast", "pyrodoor7");
cover_exit_with_door("north", "pyrodoor8");
set_door_name("pyrodoor7", "wall");
//normally you should not call this without also setting a key, but the player
//is not supposed to be able to open this door without breaking it down
set_locked("pyrodoor8", 1);
//do not allow the player to mess with the southern wall
//note: in this implementation, if the doors were to be reset, the player
//would be trapped in this and the next room until somebody came by and opened
//the wall from the other side. Not recommended for regular mud rooms unless
//you make sure they have a way out.
set_door_func("pyrodoor7", "open", (:deny_wall_action:));
set_door_func("pyrodoor7", "close", (:deny_wall_action:));
set_door_func("pyrodoor7", "lock", (:deny_wall_action:));
set_door_func("pyrodoor7", "unlock", (:deny_wall_action:));
set_door_func("pyrodoor8", "close", (:deny_door_broken:), "broken");
}
/*prototipo: int get_lock(char *srvName,char *dirName,char *idBucket,BUCKET_T *buffer)
*objetivo: verificar se o servidor que ira executar operacao de escrita adquiriu o lock ou nao*/
int get_lock(char *srvName,char *dirName,char *idBucket,BUCKET_T *buffer){
char lock_flag;
BUCKET_T header;
char lock_owner[SRVNAME_SIZE];
int locked;
lock_flag = ' ';
locked = 0;
header = *buffer;
memset(lock_owner,'\0',SRVNAME_SIZE);
/*utilizar check_locked() para verifcar se o servidor ja adquiriu o lock
se ele ja tiver adquirido lock, locked vai retornar 1 e lock_owner vai
retornar o nome do servidor*/
state = check_locked(idBucket,srvName,&locked,lock_owner);
/*somente sera requerido lock se nao houver lock no bufffer
se o buffer ja tiver bloqueado pelo proprio servidor que esta pedindo
vai retornar 1 permitindo a operacao de escrita*/
if((state == 1) && (locked == 0) && (strlen(lock_owner) == 0) ){
// conecta-se ao pool/servidor
state = set_server(cluster,srvName,&ioctx);
if(state < 0){
fprintf(stderr,"[get_lock/iceph.c] Servidor não localizado!\n");
return 1;
}
//seta o diretorio
state = set_directory(dirName,&ioctx);
if(state >= 0){
state = read_object(ioctx,idBucket,&lock_flag,LOCK_FLAG_SIZE,0,0);
if(state >= 0){
if(lock_flag == '0'){
lock_flag = '1';
//altera o flag em disco
state = write_object(ioctx,idBucket,&lock_flag,LOCK_FLAG_SIZE,0,0);
if(state >= 0){
//altera no buffer
*(header+LCKFLAG_OFFSET) = lock_flag;
//altera o parametro locked no buffer_pool
state = set_locked(idBucket,srvName,lock_flag);
}
}else
return 0;
}else
return 0; //retorna 0 pois nao conseguir escrever no bucket
}else{
fprintf(stderr,"[get_lock/iceph.c] Diretório não localizado!\n");
return 0;
}
header = NULL;
}else if((state == 1) && (locked == 1))
return 1; //srvName ja adquiriu o lock neste buffer
return 1;
}
/*---------------------------------------------------------------------------*/
int
rtimer_set(struct rtimer *rtimer, rtimer_clock_t time,
rtimer_clock_t duration,
rtimer_callback_t func, void *ptr)
{
int res;
PRINTF("rtimer_set time %d\n", time);
if (locked) {
res = set_locked(rtimer, time, func, ptr);
} else {
locked = 1;
res = set_locked(rtimer, time, func, ptr);
locked = 0;
run_deferred();
}
return res;
}
int break_door(string str) {
if(str != "door" && str != "down door")
return 0;
if(query_door_status("pyrodoor8") == "broken") {
return notify_fail("The door is already broken.\n");
}
write("You place a firm kick in the center of the door and snap it off of its hinges.");
message("say", this_player()->query_cap_name()+" breaks the door off its hinges.",
environment(this_player()), this_player());
set_door_status("pyrodoor8", "broken");
set_closed("pyrodoor8", 0);
set_locked("pyrodoor8", 0);
return 1;
}
void create() {
::create();
set_property("indoors",1);
set_property("light",1);
set("short","Palace");
set("long","This room explains why this hall is well kept, yet mostly "
"unused. On the east wall is a large set of double doors, engraved with intricate "
"symbols. The decorations abruptly end here, while the hall continues north. "
"The red carpet leads right up to the doors. This room must belong to royalty.");
set_smell("default","There is a fresh breeze in this part of the palace.");
set_listen("default","It is fairly quiet here.");
set_items((["wall":"The wall is quite plain here on the second floor.",
"doors":"The immense doors have been carved with great care.",
"decorations":"They stop abruptly after the room to the east.",
"carpet":"The %^RED%^crimson carpet%^RESET%^ covers the ground."]));
set_door("door", ROOMS "palace27.c", "enter", "bedroom key");
set_open("door", 1);
set_locked("door", 0);
set_exits((["north":ROOMS "palace26.c","south":ROOMS "palace24.c","enter":ROOMS "palace27.c"]));
}
acl_int64 aio_timer_callback::trigger(void)
{
// sanity check
if (tasks_.empty())
return TIMER_EMPTY;
acl_assert(length_ > 0);
set_time();
std::list<aio_timer_task*>::iterator it, next;
std::list<aio_timer_task*> tasks;
aio_timer_task* task;
// 从定时器中取出到达的定时任务
for (it = tasks_.begin(); it != tasks_.end(); it = next)
{
if ((*it)->when > present_)
break;
next = it;
++next;
task = *it;
tasks_.erase(it);
length_--;
tasks.push_back(task);
}
// 有可能这些到达的定时任务已经被用户提前删除了
if (tasks.empty())
{
acl_assert(!tasks_.empty());
aio_timer_task* first = tasks_.front();
acl_int64 delay = first->when - present_;
return delay < 0 ? 0 : delay;
}
// 将到达的定时任务重新放回至定时器的任务列表中，
// 并开始触发所有的到达的定时任务
// 必须先设置触发器的忙状态，以防止子类在回调过程
// 中调用了该类对象的析构过程
set_locked();
// 设置解锁后销毁标志为 false，因为当前该定时器处于
// 锁定状态，所以其它类对象不能直接在锁定时销毁本类
// 对象，当解锁后，如果该标识被置为 true，则本类对象
// 应该自动销毁
destroy_on_unlock_ = false;
for (it = tasks.begin(); it != tasks.end(); ++it)
{
set_task(*it);
timer_callback((*it)->id);
}
tasks.clear();
// 允许之后的操作中被子类调用析构过程
unset_locked();
// 子类有可能会在 timer_callback 中删除了所有的定时任务
if (tasks_.empty())
return TIMER_EMPTY;
aio_timer_task* first = tasks_.front();
acl_int64 delay = first->when - present_;
// 如果在加锁期间外部程序要求释放该对象，则在此处释放
if (destroy_on_unlock_)
{
destroy();
return -1;
}
return delay < 0 ? 0 : delay;
}
void manage_window(xcb_window_t win, rule_consequence_t *csq, int fd)
{
monitor_t *m = mon;
desktop_t *d = mon->desk;
node_t *f = mon->desk->focus;
parse_rule_consequence(fd, csq);
if (!csq->manage) {
free(csq->layer);
free(csq->state);
window_show(win);
return;
}
if (csq->node_desc[0] != '\0') {
coordinates_t ref = {m, d, f};
coordinates_t trg = {NULL, NULL, NULL};
if (node_from_desc(csq->node_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.desktop;
f = trg.node;
}
} else if (csq->desktop_desc[0] != '\0') {
coordinates_t ref = {m, d, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (desktop_from_desc(csq->desktop_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.desktop;
f = trg.desktop->focus;
}
} else if (csq->monitor_desc[0] != '\0') {
coordinates_t ref = {m, NULL, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (monitor_from_desc(csq->monitor_desc, &ref, &trg)) {
m = trg.monitor;
d = trg.monitor->desk;
f = trg.monitor->desk->focus;
}
}
if (csq->sticky) {
m = mon;
d = mon->desk;
f = mon->desk->focus;
}
if (csq->split_dir[0] != '\0' && f != NULL) {
direction_t dir;
if (parse_direction(csq->split_dir, &dir)) {
presel_dir(m, d, f, dir);
}
}
if (csq->split_ratio != 0 && f != NULL) {
presel_ratio(m, d, f, csq->split_ratio);
}
node_t *n = make_node(win);
client_t *c = make_client();
c->border_width = csq->border ? d->border_width : 0;
n->client = c;
initialize_client(n);
update_floating_rectangle(n);
if (c->floating_rectangle.x == 0 && c->floating_rectangle.y == 0) {
csq->center = true;
}
c->min_width = csq->min_width;
c->max_width = csq->max_width;
c->min_height = csq->min_height;
c->max_height = csq->max_height;
monitor_t *mm = monitor_from_client(c);
embrace_client(mm, c);
adapt_geometry(&mm->rectangle, &m->rectangle, n);
if (csq->center) {
window_center(m, c);
}
snprintf(c->class_name, sizeof(c->class_name), "%s", csq->class_name);
snprintf(c->instance_name, sizeof(c->instance_name), "%s", csq->instance_name);
f = insert_node(m, d, n, f);
clients_count++;
put_status(SBSC_MASK_NODE_MANAGE, "node_manage %s %s 0x%X 0x%X\n", m->name, d->name, win, f!=NULL?f->id:0);
if (f != NULL && f->client != NULL && csq->state != NULL && *(csq->state) == STATE_FLOATING) {
c->last_layer = c->layer = f->client->layer;
}
if (csq->layer != NULL) {
c->last_layer = c->layer = *(csq->layer);
}
if (csq->state != NULL) {
set_state(m, d, n, *(csq->state));
c->last_state = c->state;
}
set_locked(m, d, n, csq->locked);
set_sticky(m, d, n, csq->sticky);
set_private(m, d, n, csq->private);
arrange(m, d);
bool give_focus = (csq->focus && (d == mon->desk || csq->follow));
if (give_focus) {
focus_node(m, d, n);
} else if (csq->focus) {
activate_node(m, d, n);
} else {
stack(d, n, false);
}
uint32_t values[] = {CLIENT_EVENT_MASK | (focus_follows_pointer ? XCB_EVENT_MASK_ENTER_WINDOW : 0)};
xcb_change_window_attributes(dpy, win, XCB_CW_EVENT_MASK, values);
if (d == m->desk) {
window_show(n->id);
} else {
window_hide(n->id);
}
/* the same function is already called in `focus_node` but has no effects on unmapped windows */
if (give_focus) {
xcb_set_input_focus(dpy, XCB_INPUT_FOCUS_POINTER_ROOT, win, XCB_CURRENT_TIME);
}
ewmh_set_wm_desktop(n, d);
ewmh_update_client_list(false);
free(csq->layer);
free(csq->state);
}
void manage_window(xcb_window_t win, rule_consequence_t *csq, int fd)
{
monitor_t *m = mon;
desktop_t *d = mon->desk;
node_t *f = mon->desk->focus;
parse_rule_consequence(fd, csq);
if (!csq->manage) {
free(csq->layer);
free(csq->state);
window_show(win);
return;
}
if (csq->node_desc[0] != '\0') {
coordinates_t ref = {m, d, f};
coordinates_t trg = {NULL, NULL, NULL};
if (node_from_desc(csq->node_desc, &ref, &trg) == SELECTOR_OK) {
m = trg.monitor;
d = trg.desktop;
f = trg.node;
}
} else if (csq->desktop_desc[0] != '\0') {
coordinates_t ref = {m, d, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (desktop_from_desc(csq->desktop_desc, &ref, &trg) == SELECTOR_OK) {
m = trg.monitor;
d = trg.desktop;
f = trg.desktop->focus;
}
} else if (csq->monitor_desc[0] != '\0') {
coordinates_t ref = {m, NULL, NULL};
coordinates_t trg = {NULL, NULL, NULL};
if (monitor_from_desc(csq->monitor_desc, &ref, &trg) == SELECTOR_OK) {
m = trg.monitor;
d = trg.monitor->desk;
f = trg.monitor->desk->focus;
}
}
if (csq->sticky) {
m = mon;
d = mon->desk;
f = mon->desk->focus;
}
if (csq->split_dir[0] != '\0' && f != NULL) {
direction_t dir;
if (parse_direction(csq->split_dir, &dir)) {
presel_dir(m, d, f, dir);
}
}
if (csq->split_ratio != 0 && f != NULL) {
presel_ratio(m, d, f, csq->split_ratio);
}
node_t *n = make_node(win);
client_t *c = make_client();
c->border_width = csq->border ? d->border_width : 0;
n->client = c;
initialize_client(n);
initialize_floating_rectangle(n);
if (c->floating_rectangle.x == 0 && c->floating_rectangle.y == 0) {
csq->center = true;
}
monitor_t *mm = monitor_from_client(c);
embrace_client(mm, c);
adapt_geometry(&mm->rectangle, &m->rectangle, n);
if (csq->center) {
window_center(m, c);
}
snprintf(c->class_name, sizeof(c->class_name), "%s", csq->class_name);
snprintf(c->instance_name, sizeof(c->instance_name), "%s", csq->instance_name);
f = insert_node(m, d, n, f);
clients_count++;
put_status(SBSC_MASK_NODE_MANAGE, "node_manage 0x%08X 0x%08X 0x%08X 0x%08X\n", m->id, d->id, win, f!=NULL?f->id:0);
if (f != NULL && f->client != NULL && csq->state != NULL && *(csq->state) == STATE_FLOATING) {
c->layer = f->client->layer;
}
if (csq->layer != NULL) {
c->layer = *(csq->layer);
}
if (csq->state != NULL) {
set_state(m, d, n, *(csq->state));
}
set_hidden(m, d, n, csq->hidden);
set_sticky(m, d, n, csq->sticky);
set_private(m, d, n, csq->private);
set_locked(m, d, n, csq->locked);
arrange(m, d);
uint32_t values[] = {CLIENT_EVENT_MASK | (focus_follows_pointer ? XCB_EVENT_MASK_ENTER_WINDOW : 0)};
xcb_change_window_attributes(dpy, win, XCB_CW_EVENT_MASK, values);
if (d == m->desk) {
show_node(d, n);
} else {
hide_node(d, n);
}
if (!csq->hidden && csq->focus) {
if (d == mon->desk || csq->follow) {
focus_node(m, d, n);
} else {
activate_node(m, d, n);
}
} else {
stack(d, n, false);
}
ewmh_set_wm_desktop(n, d);
ewmh_update_client_list(false);
free(csq->layer);
free(csq->state);
}
