//----[ D3DXImage ]---------------------------------------------------------- D3DXImage::D3DXImage() { member("Source File", &mySourceFile); member("Color Key", &myColorKey); member("Horizontal Sub-Images", &mySubImageColumns); member("Vertical Sub-Images", &mySubImageRows); member("Selected Sub-Image", &mySubImage); // Set the default values for sub-images (single division) mySubImageColumns.setValue(1); mySubImageRows.setValue(1); // Select the first sub-image mySubImage.setValue(0); }
void member_context(){ Context c = create_context(); Principal p1 = principal_pcpl(A); Principal p2 = principal_pcpl(B); Formula f1 = formula_pred(OK, p1); Formula f2 = formula_pred(OK, p2); bool b = member(c, f1); if (b != 1) cprintf("ERROR: f1 is in the context 1 == %u\n", b); b = member(c, f2); if (b != 0) cprintf("ERROR: f2 is not in the context 0 == %u\n", b); }
/** * Get the effective user of an object. This comes from the object's effective * uid (euid) and is of the form {username}@{uid}. * * @param ob the target object * @return the user of the object */ string get_user(object ob) { string euid = geteuid(ob); string result; int pos = member(euid, '@'); if (pos != -1) { result = euid[0..(pos - 1)]; }
/* Description: Returns the hash of some value. Parameters: val - Value to be hashed Returns: The hash Notes: The value is unique for the lifetime of the server. */ int hash( mixed val ) { if( !member( hashtable, val ) ) hashtable[val] = rand32(); return hashtable[val]; }
bool SCSIPathSet::setObject ( const SCSITargetDevicePath * path ) { bool result = false; STATUS_LOG ( ( "+SCSIPathSet::setObject\n" ) ); result = member ( path ); require ( ( result == false ), ErrorExit ); STATUS_LOG ( ( "calling super::setObject()\n" ) ); result = super::setObject ( path ); STATUS_LOG ( ( "-SCSIPathSet::setObject\n" ) ); return result; ErrorExit: result = false; STATUS_LOG ( ( "-SCSIPathSet::setObject\n" ) ); return result; }
void Library::addMember() { /* * addMember - prompts the user for patron info and uses it to * create a Patron, which is added to members */ if (DBG_FUN) std::cout << "Library::addMember" << std::endl; std::string tmpName; // temporary storage for user input std::string tmpID; std::cout << "Enter member name (first then last): "; getline(std::cin, tmpName); // No validation is done on input std::cout << "Enter member ID # (P###): "; getline(std::cin, tmpID); int checkID = findMember(tmpID); // Look for tmpID in members if ( checkID >=0 ) { std::cout << "Sorry, that member ID is already in use." << std::endl; return; } Patron member(tmpID, tmpName); members.push_back(member); std::cout << "Added member " << tmpName << " with ID " << tmpID <<std::endl; }
TEST(MockReplicaSetTest, ReplSetGetStatusNode0) { MockReplicaSet replSet("n", 3); set<string> expectedMembers; expectedMembers.insert("$n0:27017"); expectedMembers.insert("$n1:27017"); expectedMembers.insert("$n2:27017"); BSONObj cmdResponse; MockRemoteDBServer* node = replSet.getNode("$n0:27017"); const MockRemoteDBServer::InstanceID id = node->getInstanceID(); bool ok = node->runCommand(id, "foo.bar", BSON("replSetGetStatus" << 1), cmdResponse); ASSERT(ok); ASSERT_EQUALS("n", cmdResponse["set"].str()); ASSERT_EQUALS(1, cmdResponse["myState"].numberInt()); set<string> memberList; BSONObjIterator iter(cmdResponse["members"].embeddedObject()); while (iter.more()) { BSONElement member(iter.next()); memberList.insert(member["name"].str()); if (member["self"].trueValue()) { ASSERT_EQUALS(1, member["state"].numberInt()); ASSERT_EQUALS("$n0:27017", member["name"].str()); } else { ASSERT_EQUALS(2, member["state"].numberInt()); } } ASSERT(expectedMembers == memberList); }
char final_s(char *in, char **eow) { register char *end = *eow; char retval = 0; /* STRIP TRAILING S's */ if ((*(end - 1) == '\'') && (*(end - 2) == 's')) { *--end = '#'; *eow = end; } /* NOW LOOK FOR FINAL S */ if (*(end - 1) == 's') { *--end = '#'; *eow = end; if (member(*(end - 1), "cfkpt")) retval = 's'; else retval = 'z'; /* STRIP 'S */ if (*(end - 1) == '\'') { *--end = '#'; *eow = end; } } return(retval); }
int unset_source(dbref player, dbref loc, dbref action) { dbref oldsrc; if ((oldsrc = DBFETCH(action)->location) == NOTHING) { /* old-style, sourceless exit */ if (!member(action, DBFETCH(loc)->exits)) { return 0; } DBSTORE(DBFETCH(player)->location, exits, remove_first(DBFETCH(DBFETCH(player)->location)->exits, action)); } else { switch (Typeof(oldsrc)) { case TYPE_PLAYER: case TYPE_ROOM: case TYPE_THING: DBSTORE(oldsrc, exits, remove_first(DBFETCH(oldsrc)->exits, action)); break; default: log_status("PANIC: source of action #%d was type: %d.\n", action, Typeof(oldsrc)); return 0; /* NOTREACHED */ break; } } return 1; }
base_manager::base_manager() { scoped_istream stream = istream_file(get_prefs_file(), true); read(prefs, *stream); if (member().empty()) { std::stringstream strstr; std::map<int, int> member; member.insert(std::make_pair(172, 5)); member.insert(std::make_pair(176, 6)); member.insert(std::make_pair(244, 7)); member.insert(std::make_pair(279, 8)); member.insert(std::make_pair(103, 8)); member.insert(std::make_pair(106, 9)); member.insert(std::make_pair(120, 9)); member.insert(std::make_pair(381, 9)); for (std::map<int ,int>::const_iterator it = member.begin(); it != member.end(); ++ it) { if (it != member.begin()) { strstr << ", "; } strstr << ((it->second << 16) | it->first); } set_member(strstr.str()); } }
void SecurityManager::deleteUser(const QString &name) { if (isSql()) { QSqlQuery q; q.setForwardOnly(true); q.prepare("delete from trainers where name=:name"); q.bindValue(":name", name.toLower()); q.exec(); return; } Member m = member(name); assert (m.name.length() > 0); m.name[0] = ':'; //invalid character, will not get loaded when reloading database memberFile.seek(m.filepos); members[name].write(&memberFile); memberFile.flush(); playersByIp.remove(m.ip, name); authed.remove(name); members.erase(name); bannedMembers.remove(name.toLower()); if (bannedIPs.contains(m.ip) && !playersByIp.contains(m.ip)) { bannedIPs.remove(m.ip); } }
/* Beware -- 70% of total CPU time is spent in this subroutine - if you don't believe me - try it yourself ! */ void nextstate(int s, int c) { int j, *newpos; uint8_t *temp, *tz; int *pos, i, *f, num, curpos, number; /* state to goto from state s on char c */ num = *state[s]; temp = tmpstat; pos = state[s] + 1; for(i = 0; i<num; i++){ curpos = *pos++; j = name[curpos]; if(j < NCH && j == c || j == RSTR && c == right[curpos] || j == RCCL && member(c, ptr[curpos])){ f = foll[curpos]; number = *f; newpos = f+1; for(j=0;j<number;j++) temp[*newpos++] = 2; } } j = 0; tz = temp + tptr; while(temp < tz){ if(*temp == 2){ j++; *temp++ = 1; } else *temp++ = 0; } count = j; }
int main(int argc, char **argv){ /* one argument = autoclose test*/ int count = 0; tuplespace_t ts; if(argc == 2){ m_tuplespace_init(&ts, sizeof(tuple_t), 0, TUPLESPACE_OPTIONAUTOCLOSE); m_tuplespace_close_at(&ts, 1); } else m_tuplespace_init(&ts, sizeof(tuple_t), 0, 0); int i[] = {1, 2, 3, 4}; m_tuplespace_put(&ts, i, 4); m_thread_register(); if(argc != 2) m_tuplespace_close(&ts); int n = 1; int x; while(m_tuplespace_get(&ts, 1, &x) != TUPLESPACE_CLOSED){ printf("%d\n", x); count++; if(!member(i, sizeof(i)/sizeof(int), x)){ return EXIT_FAILURE; } } if(count != sizeof(i)/sizeof(int)) return EXIT_FAILURE; return EXIT_SUCCESS; }
int ignore1(char **list, struct ignoretab *tab, const char *which) { char field[LINESIZE]; char **ap; struct ignore *igp; int h; if (*list == NULL) return (igshow(tab, which)); for (ap = list; *ap != 0; ap++) { istrncpy(field, *ap, sizeof(field)); if (member(field, tab)) continue; h = hash(field); igp = calloc(1, sizeof(struct ignore)); igp->i_field = calloc((unsigned)strlen(field) + 1, sizeof(char)); strcpy(igp->i_field, field); igp->i_link = tab->i_head[h]; tab->i_head[h] = igp; tab->i_count++; } return (0); }
void Dijkstra(int p, int w[N][N], int d[N]) { int i, u, x, k; int j, m; struct vertices U, V; set_vertices(&V, FALSE); set_vertices(&U, TRUE); for (i = 0; i < N; i++) { d[i] = M; } d[p] = 0; printf("(3)\n"); printf(" (a)\n"); while (remain(&U)) { u = select_min(d, &U); /* (ア) */ /* (3)(a) */ printf(" u == %d\n", u); add_vertex(u, &V); remove_vertex(u, &U); for (x = 0; x < N; x++) { if (w[u][x] < M && member(x, &U)) { k = d[u] + w[u][x]; if (k < d[x]) { d[x] = k; } } } } }
mixed *insert(object obj) { if (!member(obj)) return ::insert(obj); else return NULL; }
set<Item>& set<Item>::operator-=(const Item& q) { int i; // is it present? if ((i = member(q)) < 0) return *this; // retain sortedness if it's not too expensive if (sorted && (sz - i < 64)) { --sz; for (; i<sz; ++i) p[i] = p[i+1]; return *this; } // otherwise, substitute last member if (sz > 1) p[i] = p[sz-1]; --sz; sorted = 0; return *this; }
static void display_user(struct xpasswd *pwd) { struct xgroup *grp; unsigned int i; char cbuf[16], ebuf[16]; struct tm *tm; grp = find_group_bygid(pwd->pw_gid); printf(o_flag ? "%s:%ld:%s:%ld:%s" : "%-15s %-7ld %-15s %-7ld %s\n", pwd->pw_name, (long)pwd->pw_uid, grp ? grp->gr_name : "", (long)pwd->pw_gid, pwd->pw_gecos); if (m_flag) { for (i = 0, grp = grps; i < ngrps; ++i, ++grp) { if (grp->gr_gid == pwd->pw_gid || !member(pwd->pw_name, grp->gr_mem)) continue; printf(o_flag ? "%s:%s:%ld" : "%24s%-15s %-7ld\n", "", grp->gr_name, (long)grp->gr_gid); } } if (x_flag) { printf(o_flag ? "%s:%s" : "%24s%s\n", "", pwd->pw_dir); printf(o_flag ? "%s:%s" : "%24s%s\n", "", pwd->pw_shell); } if (a_flag) { tm = gmtime(&pwd->pw_change); strftime(cbuf, sizeof(cbuf), pwd->pw_change ? "%F" : "0", tm); tm = gmtime(&pwd->pw_expire); strftime(ebuf, sizeof(ebuf), pwd->pw_expire ? "%F" : "0", tm); printf(o_flag ? "%s:%s:%s" : "%24s%s %s\n", "", cbuf, ebuf); } if (o_flag) printf("\n"); }
int ignore1(char **list, struct ignoretab *tab, char *which) { char field[LINESIZE]; char **ap; struct ignore *igp; int h; if (*list == NULL) return(igshow(tab, which)); for (ap = list; *ap != 0; ap++) { istrlcpy(field, *ap, sizeof(field)); if (member(field, tab)) continue; h = hash(field); igp = (struct ignore *)calloc(1, sizeof(struct ignore)); if (igp == NULL) errx(1, "Out of memory"); igp->i_field = strdup(field); if (igp->i_field == NULL) errx(1, "Out of memory"); igp->i_link = tab->i_head[h]; tab->i_head[h] = igp; tab->i_count++; } return(0); }
int exit_action() { object dest; if( !member(query_spots(), this_player()->query_coord()) ) { msg("To go that way, you must walk onto the pad."); return 0; } else if( !query_active() ) { msg("The pad is inactive."); return 0; } dest = get_destination( link ); if( !dest ) { msg( "That exit doesn't seem to lead anywhere!"); debug(object_name(this_object()) + " complains: I'm an unlinked exit."); return 0; } this_player()->move_player( dest, "teleport" ); if( dest_coord ) this_player()->set_coord( dest_coord ); if( this_player()->query_is_player() || this_player()->query_possessor() ) "/bin/look"->main(); return 1; }
//p and q are lists of atoms with no atom appearing twice in p and no atom appearing twice in q. p and q represent sets. this forms the intersection. list intersection(list p, list q) { if(is_null(p) || is_null(q)) return null(); if(member(car(p),q)) return cons(car(p),intersection(cdr(p),q)); return intersection(cdr(p),q); }
CAgentManager::~CAgentManager () { VERIFY (member().members().empty()); #ifdef USE_SCHEDULER_IN_AGENT_MANAGER remove_scheduler (); #endif // USE_SCHEDULER_IN_AGENT_MANAGER remove_components (); }
Lisp<Fixed> Project::fixed() const { Lisp<Fixed> fixed; for (Lisp<Fixed> f = source->fixed(); ! nil(f); ++f) if (member(flds, f->field)) fixed.push(*f); return fixed; }
DOLIST(list, list) { if (list == thing) return 1; if ((DBFETCH(list)->contents) && (member(thing, DBFETCH(list)->contents))) { return 1; } }
//forms the set which is their union--if p and q share an atom, the atom appears only once in the union list list_union(list p, list q) { if(is_null(p)) return q; if(!member(car(p),q)) return cons(car(p), list_union(cdr(p), q)); return list_union(cdr(p),q); }
bool UserVariableManager::Exists(const wxString& variable) const { if (variable.find(_T('#')) == wxString::npos) return false; wxString member(variable.AfterLast(wxT('#')).BeforeFirst(wxT('.')).BeforeFirst(wxT(')')).MakeLower()); return !m_CfgMan->Exists(cSets + m_ActiveSet + _T('/') + member + _T("/base")); }
aligned_t Task::qthread_func( void * arg ) { Task * const task = reinterpret_cast< Task * >(arg); // First member of the team change state to executing. // Use compare-exchange to avoid race condition with a respawn. Kokkos::atomic_compare_exchange_strong( & task->m_state , int(Kokkos::Experimental::TASK_STATE_WAITING) , int(Kokkos::Experimental::TASK_STATE_EXECUTING) ); if ( task->m_apply_team && ! task->m_apply_single ) { Kokkos::Impl::QthreadTeamPolicyMember::TaskTeam task_team_tag ; // Initialize team size and rank with shephered info Kokkos::Impl::QthreadTeamPolicyMember member( task_team_tag ); (*task->m_apply_team)( task , member ); #if 0 fprintf( stdout , "worker(%d.%d) task 0x%.12lx executed by member(%d:%d)\n" , qthread_shep() , qthread_worker_local(NULL) , reinterpret_cast<unsigned long>(task) , member.team_rank() , member.team_size() ); fflush(stdout); #endif member.team_barrier(); if ( member.team_rank() == 0 ) task->closeout(); member.team_barrier(); } else if ( task->m_apply_team && task->m_apply_single == reinterpret_cast<function_single_type>(1) ) { // Team hard-wired to one, no cloning Kokkos::Impl::QthreadTeamPolicyMember member ; (*task->m_apply_team)( task , member ); task->closeout(); } else { (*task->m_apply_single)( task ); task->closeout(); } #if 0 fprintf( stdout , "worker(%d.%d) task 0x%.12lx return\n" , qthread_shep() , qthread_worker_local(NULL) , reinterpret_cast<unsigned long>(task) ); fflush(stdout); #endif return 0 ; }
//takes two non-atomic recursive lists and returns true if p and q contain at least one atom in common int two_the_same(list p, list q) { if(is_null(p)) return false; if(atom(p)) return member(p,q); return two_the_same(car(p),q) || two_the_same(cdr(p),q); }
static void mnpc_create() { if (PO && member(inherit_list(PO), "/std/room.c")!=-1) Set(MNPC_HOME, object_name(PO)); else if (PL && ENV(PL)) Set(MNPC_HOME, object_name(ENV(PL))); else Set(MNPC_HOME, MNPC_DFLT_HOME); Set(P_MNPC, 1); Set(MNPC_AREA, ({}));
inline UnknownElement& Object::operator [](const std::string& name) { iterator it = Find(name); if (it == m_Members.end()) { Member member(name); it = Insert(member, End()); } return it->element; }