//----[ 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;
}
