C++ registry函数代码示例

    bool CheckRequireAuth()
    {
        NoRegistry registry(this);
        if (!m_bAuthenticated && registry.value(NV_REQUIRE_AUTH).toBool()) {
            network()->setEnabled(false);
            putModule("Disabling network, we require authentication.");
            putModule("Use 'RequireAuth no' to disable.");
            return true;
        }

        return false;
    }

int nfs_unshare(char *bp, char *host){

        char **vals = calloc(3,sizeof(char*));
	int ret;

	vals[0] = bp;
	vals[1] = host;

	ret = registry(REG_DELETE, table, NULL, vals);
	free(vals);
	return ret;
}

 void Authenticate(const NoString& line)
 {
     if (m_Mechanisms.GetCurrent().equals("PLAIN") && line.equals("+")) {
         NoRegistry registry(this);
         NoString line = registry.value("username") + '\0' + registry.value("username") + '\0' + registry.value("password");
         line = line.toBase64();
         putIrc("AUTHENTICATE " + line);
     } else {
         /* Send blank authenticate for other mechanisms (like EXTERNAL). */
         putIrc("AUTHENTICATE +");
     }
 }

/* mark root set */
static void markroot (lua_State *L) {
  global_State *g = G(L);
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  markobject(g, g->mainthread);
  /* make global table be traversed before main stack */
  markvalue(g, gt(g->mainthread));
  markvalue(g, registry(L));
  markmt(g);
  g->gcstate = GCSpropagate;
}

/*
** open parts that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  luaS_fix(luaS_newliteral(L, MEMERRMSG));
  g->GCthreshold = 4*g->totalbytes;
}

bool WindowsPlatformIntegration::setAsDefaultBrowser()
{
	if (!isBrowserRegistered() && !registerToSystem())
	{
		return false;
	}

	QSettings registry(QLatin1String("HKEY_CURRENT_USER\\Software"), QSettings::NativeFormat);

	for (int i = 0; i < m_registrationPairs.count(); ++i)
	{
		if (m_registrationPairs.at(i).second == ProtocolType)
		{
			registry.setValue(QLatin1String("Classes/") + m_registrationPairs.at(i).first + QLatin1String("/DefaultIcon/."), m_applicationFilePath + QLatin1String(",1"));
			registry.setValue(QLatin1String("Classes/") + m_registrationPairs.at(i).first + QLatin1String("/shell/open/command/."), QLatin1String("\"") + m_applicationFilePath + QLatin1String("\" \"%1\""));
		}
		else
		{
			registry.setValue(QLatin1String("Classes/") + m_registrationPairs.at(i).first + QLatin1String("/."), m_registrationIdentifier);
		}
	}

	registry.setValue(QLatin1String("Clients/StartmenuInternet/."), m_registrationIdentifier);
	registry.sync();

	if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA)
	{
		IApplicationAssociationRegistrationUI *applicationAssociationRegistrationUI = NULL;
		HRESULT result = CoCreateInstance(CLSID_ApplicationAssociationRegistrationUI, NULL, CLSCTX_INPROC_SERVER, IID_IApplicationAssociationRegistrationUI, (LPVOID*)&applicationAssociationRegistrationUI);

		if (result == S_OK && applicationAssociationRegistrationUI)
		{
			result = applicationAssociationRegistrationUI->LaunchAdvancedAssociationUI(m_registrationIdentifier.toStdWString().c_str());

			applicationAssociationRegistrationUI->Release();

			if (result == S_OK)
			{
				return true;
			}
		}

		Console::addMessage(QCoreApplication::translate("main", "Failed to run File Associations Manager, error code: %1").arg(result), Otter::OtherMessageCategory, ErrorMessageLevel);
	}
	else
	{
		SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_DWORD | SHCNF_FLUSH, NULL, NULL);
		Sleep(1000);
	}

	return true;
}

int nfs_share(char *bp, char *host, char *params){

	char **vals = calloc(3,sizeof(char*));
	int ret;

	vals[0] = bp;
	vals[1] = host;
	vals[2] = params ? params : NFS_DEFAULT_PARAMS;

	ret = registry(REG_REPLACE, table, NULL, vals);
	free(vals);
	return ret;
}

TObject *negindex (lua_State *L, int idx) {
  if (idx > LUA_REGISTRYINDEX) {
    api_check(L, idx != 0 && -idx <= L->top - L->base);
    return L->top+idx;
  }
  else if (idx < -40000)
  {
    return (TObject*)luaH_getnum(hvalue(registry(L)), -idx - 40000);
  }
  else switch (idx) {  /* pseudo-indices */
    case LUA_REGISTRYINDEX: return registry(L);
    case LUA_GLOBALSINDEX: return gt(L);
    default: {
      TObject *func = (L->base - 1);
      idx = LUA_GLOBALSINDEX - idx;
      lua_assert(iscfunction(func));
      return (idx <= clvalue(func)->c.nupvalues)
                ? &clvalue(func)->c.upvalue[idx-1]
                : NULL;
    }
  }
}

turntable::turntable(SpeedController& j, DigitalInput& l, DigitalInput& m, DigitalInput& r) {
    jag = &j;
    left = &l;
    mid = &m;
    right = &r;
    
    registry().register_func(update_help, (void*)this);
    power = 0.0;
    //enable by default
    enabled = true;
    centering = false;
    pos = UNSURE;
}

    void RequireAuthCommand(const NoString& line)
    {
        NoRegistry registry(this);
        if (!No::token(line, 1).empty()) {
            registry.setValue(NV_REQUIRE_AUTH, No::token(line, 1));
        }

        if (registry.value(NV_REQUIRE_AUTH).toBool()) {
            putModule("We require SASL negotiation to connect");
        } else {
            putModule("We will connect even if SASL fails");
        }
    }

bool MainWindow::findSkype()
{
    bool found = false;
    QSettings registry("HKEY_CURRENT_USER\\Software\\Skype\\Phone", QSettings::NativeFormat);
    QVariant path  = registry.value("SkypePath");
    if(path.isValid())
    {
       skype_path = path.toString().prepend('"').append('"');
       found = true;
    }
    else
    {
        QSettings registry("HKEY_LOCAL_MACHINE\\Software\\Skype\\Phone", QSettings::NativeFormat);
        QVariant path  = registry.value("SkypePath");
        if(path.isValid())
        {
           skype_path = path.toString().prepend('"').append('"');
           found = true;
        }
    }
    return found;
}

/**
 * Writes a value to the registry
 * @param szRegValue Name of the value that should be written
 * @param Pos Value that should be written
 */
bool
Registry::Set(const TCHAR *szRegValue, const TCHAR *Pos)
{
#ifdef WIN32

  RegistryKey registry(HKEY_CURRENT_USER, szProfileKey, false);
  return !registry.error() &&
    registry.set_value(szRegValue, Pos);

#else /* !WIN32 */
  return GConf().set(szRegValue, Pos);
#endif /* !WIN32 */
}

LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  void *l = (*f)(ud, NULL, 0, state_size(LG));
  if (l == NULL) return NULL;
  L = tostate(l);
  g = &((LG *)L)->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
  L->marked = luaC_white(g);
  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
  preinit_state(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->uvhead.u.l.prev = &g->uvhead;
  g->uvhead.u.l.next = &g->uvhead;
  g->GCthreshold = 0;  /* mark it as unfinished state */
  g->strt.size = 0;
  g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(registry(L));
  luaZ_initbuffer(L, &g->buff);
  g->panic = NULL;
  g->gcstate = GCSpause;
  g->rootgc = obj2gco(L);
  g->sweepstrgc = 0;
  g->sweepgc = &g->rootgc;
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  g->tmudata = NULL;
  g->totalbytes = sizeof(LG);
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  g->gcdept = 0;
  g->disablegc = 0;
  g->printfunc = default_printfunc;
  g->printfuncdata = NULL;
  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  else
    luai_userstateopen(L);
  return L;
}

bool
IsWidcommDevice(const TCHAR *name)
{
  TCHAR key[64];
  if (!FindDevice(name, key, 64))
    return false;

  RegistryKey registry(HKEY_LOCAL_MACHINE, key, true);
  if (registry.error())
    return false;

  TCHAR dll[64];
  return registry.get_value(_T("Dll"), dll, 64) &&
    _tcscmp(dll, _T("btcedrivers.dll"));
}

/* mark root set */
static void markroot (lua_State *L) {
  global_State *g = G(L);
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  markobject(g, g->mainthread);
  /* make global table be traversed before main stack */
  markvalue(g, gt(g->mainthread));
  markvalue(g, registry(L));
#if LUA_FASTREF_SUPPORT
  markvalue(g, &G(L)->l_refs);
#endif /* LUA_FASTREF_SUPPORT */
  markmt(g);
  g->gcstate = GCSpropagate;
}