示例#1
0
void TestBinaryStream::TestArray()
{
	Registry R;
	R.AddClass<Array>("Array");
	R.AddClass<int>("int");

	Pointer<Array> A = R.New<Array>();
	A->Append(R.New(0));
	A->Append(R.New(1));
	A->Append(R.New(2));
	A->Append(R.New(3));

	BinaryStream S;
	S.SetRegistry(&R);

	S << A;
	Object Q;
	S >> Q;

	KAI_TEST_FALSE(S.CanRead(1));
	KAI_TEST_EQUIV(Q.GetTypeNumber(), Type::Traits<Array>::Number);
	const Array &B = ConstDeref<Array>(Q);
	KAI_TEST_EQUIV(B.Size(), 4);
	KAI_TEST_EQUIV(ConstDeref<int>(B.At(0)), 0);
	KAI_TEST_EQUIV(ConstDeref<int>(B.At(1)), 1);
	KAI_TEST_EQUIV(ConstDeref<int>(B.At(2)), 2);
	KAI_TEST_EQUIV(ConstDeref<int>(B.At(3)), 3);
}
示例#2
0
	//*************************************************************************
	// Method:		LoadDataFromRegistry
	// Description: loads the serial number and registration key from the registry
	//	and decodes the information
	//
	// Parameters:
	//	None
	//
	// Return Value: None
	//*************************************************************************
	void RegistrationMgr::LoadDataFromRegistry()
	{
		Registry registry;

		regData->SetCustomerType(NormalCustomer);
		regData->SetNumberOfDaysValid(15);
		regData->SetFunctionalityType(TimeTrial);
		regData->SetProductType(Holodeck);
		regData->SetKeyVersion(HolodeckBasic);
		regData->SetNumberOfLicensesPurchased(0);
		regData->SetSerialNumber("");
		regData->SetRegistrationKey("");

		if (!registry.OpenKey(ROOT_KEY, ROOT_PATH, KEY_QUERY_VALUE))
			return;

		SiString serialNum, regKey;
		if (!registry.Read(SERIAL_NUMBER_VALUE_NAME, serialNum))
			return;

		if (!registry.Read(REGISTRATION_KEY_VALUE_NAME, regKey))
			return;

		regData->SetSerialNumber(serialNum);
		regData->SetRegistrationKey(regKey);

		RegistrationKeyGenerator::GetInstance()->DecodeRegistrationKey(regData);
	}
示例#3
0
void RegistrarProcess::update()
{
  if (operations.empty()) {
    return; // No-op.
  }

  CHECK(!updating);
  CHECK(error.isNone());
  CHECK_SOME(variable);

  // Time how long it takes to apply the operations.
  Stopwatch stopwatch;
  stopwatch.start();

  updating = true;

  // Create a snapshot of the current registry.
  Registry registry = variable.get().get();

  // Create the 'slaveIDs' accumulator.
  hashset<SlaveID> slaveIDs;
  foreach (const Registry::Slave& slave, registry.slaves().slaves()) {
    slaveIDs.insert(slave.info().id());
  }

  foreach (Owned<Operation> operation, operations) {
    // No need to process the result of the operation.
    (*operation)(&registry, &slaveIDs, flags.registry_strict);
  }
示例#4
0
	//*************************************************************************
	// Method:		GetNumberOfDaysRemaining
	// Description: returns the number of days remaining for this license
	//
	// Parameters:
	//	None
	//
	// Return Value: the number of days remaining for this license
	//*************************************************************************
	int RegistrationMgr::GetNumberOfDaysRemaining()
	{
		DWORD dwHighValue, dwLowValue;
		::FILETIME currentFileTime;
		ULARGE_INTEGER trialStartTime, currentTime, calculatedTime;
		int numDays;
		Registry registry;

		if (!registry.OpenKey(ROOT_KEY, ROOT_PATH, KEY_QUERY_VALUE))
			return 0;

		if (!registry.Read("Config1", dwHighValue))
			return 0;

		if (!registry.Read("Config2", dwLowValue))
			return 0;

		trialStartTime.HighPart = dwHighValue;
		trialStartTime.LowPart = dwLowValue;

		GetSystemTimeAsFileTime(&currentFileTime);
		currentTime.HighPart = currentFileTime.dwHighDateTime;
		currentTime.LowPart = currentFileTime.dwLowDateTime;

		calculatedTime.QuadPart = currentTime.QuadPart - trialStartTime.QuadPart;
        numDays = (int)((calculatedTime.QuadPart * .0000001) / 86400);	//calculated in 100ns increments

		return GetNumberOfDaysValid() - numDays;
	}
示例#5
0
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
bool InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	Registry	reg;
	int			max_x, max_y;
	HWND		hWnd;
	HMENU		sys_menu;

	hInst = hInstance; // Store instance handle in our global variable

	hWnd = CreateWindow(szWindowClass, szTitle, WS_BORDER | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
						CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

	g_hWnd = hWnd; // store hwnd in our global variable

	if (!hWnd)
		return FALSE;

	// Add items to system menu
	sys_menu = GetSystemMenu(g_hWnd, FALSE);
	AppendMenu(sys_menu, MF_SEPARATOR, 0, "");
	AppendMenu(sys_menu, MF_STRING, sys_menu_item_open, "&Open...\tCtrl-O");

	// Restore window location and size
	reg.read_reg();
	max_x = GetSystemMetrics(SM_CXSCREEN) - GetSystemMetrics(SM_CXICON);
	max_y = GetSystemMetrics(SM_CYSCREEN) - GetSystemMetrics(SM_CYICON);

	SetWindowPos(hWnd, HWND_TOP, min(reg.main_x, max_x), min(reg.main_y, max_y), 320, 240, SWP_SHOWWINDOW);
	UpdateWindow(hWnd);

	cur_frame = -1;
	cur_working_path[0] = '\0';

	return true;
}
STDAPI_(void) DllEnumRegistrationInfo(REGISTRYINFOPROC pEnumProc, LPARAM lParam)
{ try
  { OutputDebugFmt(_T("DllEnumRegistrationInfo()\n"));

    LPCTSTR prodPrefix = NULL;
    LPCTSTR compPrefix = NULL;
    TCHAR   szModulePath[MAX_PATH];

    COMServer::GetModuleFileName(szModulePath,ARRAYSIZE(szModulePath));

    VersionInfo verInfo(szModulePath);

    prodPrefix = (LPCTSTR)verInfo.GetStringInfo(_T("ProductPrefix"));
    compPrefix = (LPCTSTR)verInfo.GetStringInfo(_T("ComponentPrefix"));

    Registry registry;

    registry.SetComponentId(compPrefix);

    COMServer::GetModuleFileName(szModulePath,ARRAYSIZE(szModulePath));

    RegistryUtil::RegisterComObjectsInTypeLibrary(registry,szModulePath);

    registry.EnumRegistry(pEnumProc,lParam);
  }
  catch(BVR20983Exception e)
  { OutputDebugFmt(_T("DllRegistrationInfo(): Exception \"%s\" [%ld]>\n"),e.GetErrorMessage(),e.GetErrorCode());
    OutputDebugFmt(_T("  Filename \"%s\" Line %d\n"),e.GetFileName(),e.GetLineNo());
  }
  catch(exception& e) 
  { OutputDebugFmt(_T("DllRegistrationInfo(): Exception <%s,%s>\n"),typeid(e).name(),e.what()); }
  catch(...)
  { OutputDebugFmt(_T("DllRegistrationInfo(): Exception\n")); }
} // of DllEnumRegistrationInfo()
示例#7
0
//_______________________________________________________
void WindowManager::initializeWayland()
{
#if BREEZE_HAVE_KWAYLAND
    if( !Helper::isWayland() ) return;

    if( _seat ) {
        // already initialized
        return;
    }

    using namespace KWayland::Client;
    auto connection = ConnectionThread::fromApplication( this );
    if( !connection ) {
        return;
    }
    Registry *registry = new Registry( this );
    registry->create( connection );
    connect(registry, &Registry::interfacesAnnounced, this,
    [registry, this] {
        const auto interface = registry->interface( Registry::Interface::Seat );
        if( interface.name != 0 ) {
            _seat = registry->createSeat( interface.name, interface.version, this );
            connect(_seat, &Seat::hasPointerChanged, this, &WindowManager::waylandHasPointerChanged);
        }
    }
           );

    registry->setup();
    connection->roundtrip();
#endif
}
示例#8
0
void Registry::setCurrentRegistry(const glbinding::ContextHandle contextId)
{
    g_mutex.lock();
    auto it = s_registries.find(contextId);

    if (it != s_registries.end())
    {
        t_currentRegistry = it->second;

        g_mutex.unlock();
    }
    else
    {
        g_mutex.unlock();

        Registry * registry = new Registry();

        g_mutex.lock();
        s_registries[contextId] = registry;
        g_mutex.unlock();

        t_currentRegistry = registry;
        registry->initialize();
    }
}
示例#9
0
void RegisterBridge_PCL(Registry& reg, string parentGroup)
{
	string grp(parentGroup);
	grp.append("/pcl");

	reg.add_function("PclDebugBarrierEnabled", &PclDebugBarrierEnabled, grp,
					"Enabled", "", "Returns the whether debug barriers are enabled.");

	reg.add_function("PclDebugBarrierAll", &PclDebugBarrierAll, grp,
					 "", "", "Synchronizes all parallel processes if the executable"
							 "has been compiled with PCL_DEBUG_BARRIER=ON");

	reg.add_function("NumProcs", &pcl::NumProcs, grp,
					"NumProcs", "", "Returns the number of active processes.");

	reg.add_function("ProcRank", &pcl::ProcRank, grp,
					"ProcRank", "", "Returns the rank of the current process.");

	reg.add_function("SynchronizeProcesses", &pcl::SynchronizeProcesses, grp,
					"", "", "Waits until all active processes reached this point.");

	reg.add_function("AllProcsTrue", &PclAllProcsTrue, grp,
					 "boolean", "boolean", "Returns true if all processes call the method with true.");

	reg.add_function("ParallelMin", &ParallelMin<double>, grp, "tmax", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelMax", &ParallelMax<double>, grp, "tmin", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelSum", &ParallelSum<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");

	reg.add_function("ParallelVecMin", &ParallelVecMin<double>, grp, "tmax", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelVecMax", &ParallelVecMax<double>, grp, "tmin", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelVecSum", &ParallelVecSum<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");
}
示例#10
0
TEST(OKFliRegistryTest, TestBasic) {
  Registry r;
  r.SetName("TestReg");
  EXPECT_EQ("TestReg", r.GetName());
  EXPECT_EQ("(empty)", r.GetAllAliases());

  EXPECT_FALSE(r.IsRegistered("moof"));
  EXPECT_FALSE(r.CreateFunctor("moof"));

  r.Register<RegAddOneXform>();
  r.Register<RegAddNXform>();

  EXPECT_EQ("RegAddNXform,RegAddOneXform", r.GetAllAliases(","));

  auto f = r.CreateFunctor("RegAddNXform");
  EXPECT_TRUE(f);

  auto f2 = r.CreateFunctor("oarph");
  EXPECT_FALSE(f2);

  auto fn = r.CreateFunctor("RegAddOneXform");
  EXPECT_TRUE(fn);
  int x = 1;
  auto out = fn->Call(rt_datumptr::Reference(&x));
  EXPECT_EQ(2, out.GetRef<int>());
}
示例#11
0
	//*************************************************************************
	// Method:		SaveRegistrationData
	// Description: reloads registration data from the registry
	//
	// Parameters:
	//	None
	//
	// Return Value: the single instance of this class
	//*************************************************************************
	bool RegistrationMgr::SaveRegistrationData(const SiString &serialNumber, const SiString &registrationKey)
	{
		if ((serialNumber.GetLength() == 0) || (registrationKey.GetLength() == 0))
			return false;

		RegistrationData tempData;
		tempData.SetSerialNumber(serialNumber);
		tempData.SetRegistrationKey(registrationKey);

		if (RegistrationKeyGenerator::GetInstance()->DecodeRegistrationKey(&tempData))
		{
			Registry registry;

			if (!registry.OpenKey(ROOT_KEY, ROOT_PATH))
				return false;

			SiString serialNum, regKey;
			if (!registry.Write(SERIAL_NUMBER_VALUE_NAME, serialNumber))
				return false;

			if (!registry.Write(REGISTRATION_KEY_VALUE_NAME, registrationKey))
				return false;

			return true;
		}

		return false;
	}
示例#12
0
void TestBinaryStream::TestList()
{
	Registry R;
	List::Register(R);
	R.AddClass<void>("void");
	R.AddClass<int>("int");
	R.AddClass<String>("String");

	Pointer<List> list = R.New<List>();
	list->Append(R.New(123));
	list->Append(R.New(456));
	list->Append(R.New("Hello"));
	BinaryStream stream(R);
	stream << list;
	Object result;
	stream >> result;

	KAI_TRACE_1(list);
	KAI_TRACE_1(stream);
	KAI_TRACE_1(result);

	KAI_TEST_TRUE(result.Exists());
	KAI_TEST_TRUE(result.IsType<List>());
	KAI_TEST_EQUIV(ConstDeref<List>(result).Size(), 3);
	KAI_TEST_EQUIV(result, list);

	Pointer<List> result_list = result;
	KAI_TEST_EQUIV(ConstDeref<String>(result_list->Back()), "Hello");
	result_list->PopBack();
	KAI_TEST_EQUIV(ConstDeref<int>(result_list->Back()), 456);
	result_list->PopBack();
	KAI_TEST_EQUIV(ConstDeref<int>(result_list->Back()), 123);
	result_list->PopBack();
	KAI_TEST_EQUIV(ConstDeref<List>(result_list).Size(), 0);
}
示例#13
0
void
Licensor::init (Gtk::Tooltips& tt, Registry& wr)
{
    /* add license-specific metadata entry areas */
    rdf_work_entity_t* entity = rdf_find_entity ( "license_uri" );
    _eentry = EntityEntry::create (entity, tt, wr);

    LicenseItem *i;
    wr.setUpdating (true);
    i = manage (new LicenseItem (&_proprietary_license, _eentry, wr));
    add (*i);
    LicenseItem *pd = i;

    for (struct rdf_license_t * license = rdf_licenses;
            license && license->name;
            license++) {
        i = manage (new LicenseItem (license, _eentry, wr));
        add(*i);
    }
    // add Other at the end before the URI field for the confused ppl.
    LicenseItem *io = manage (new LicenseItem (&_other_license, _eentry, wr));
    add (*io);

    pd->set_active();
    wr.setUpdating (false);

    Gtk::HBox *box = manage (new Gtk::HBox);
    pack_start (*box, true, true, 0);

    box->pack_start (_eentry->_label, false, false, 5);
    box->pack_start (*_eentry->_packable, true, true, 0);

    show_all_children();
}
示例#14
0
void TestBinaryStream::TestObject()
{
	Registry R;
	R.AddClass<int>("int");

	BinaryStream S;
	S.SetRegistry(&R);

	Pointer<int> N = R.New(42);
	S << N;
	Object Q;
	S >> Q;
	KAI_TEST_FALSE(S.CanRead(1));
	KAI_TEST_EQUIV(Q.GetTypeNumber(), Type::Traits<int>::Number);
	KAI_TEST_EQUIV(ConstDeref<int>(Q), 42);

	S.Clear();
	KAI_TEST_TRUE(S.Empty());

	N.Set("child0", R.New(123));
	S << N;
	Object M;
	S >> M;
	KAI_TEST_FALSE(S.CanRead(1));
	KAI_TEST_EQUIV(ConstDeref<int>(M), 42);
	KAI_TEST_TRUE(M.Has("child0"));
	KAI_TEST_EQUIV(ConstDeref<int>(M.Get("child0")), 123);
}
示例#15
0
void RegisterLuaUserDataType(Registry& reg, string type, string grp)
{
	string suffix = GetDimensionSuffix<dim>();
	string tag = GetDimensionTag<dim>();

//	LuaUser"Type"
	{
		typedef ug::LuaUserData<TData, dim> T;
		typedef CplUserData<TData, dim> TBase;
		string name = string("LuaUser").append(type).append(suffix);
		reg.add_class_<T, TBase>(name, grp)
			.template add_constructor<void (*)(const char*)>("Callback")
			.template add_constructor<void (*)(LuaFunctionHandle)>("handle")
			.set_construct_as_smart_pointer(true);
		reg.add_class_to_group(name, string("LuaUser").append(type), tag);
	}

//	LuaCondUser"Type"
	{
		typedef ug::LuaUserData<TData, dim, bool> T;
		typedef CplUserData<TData, dim, bool> TBase;
		string name = string("LuaCondUser").append(type).append(suffix);
		reg.add_class_<T, TBase>(name, grp)
			.template add_constructor<void (*)(const char*)>("Callback")
			.template add_constructor<void (*)(LuaFunctionHandle)>("handle")
			.set_construct_as_smart_pointer(true);
		reg.add_class_to_group(name, string("LuaCondUser").append(type), tag);
	}
}
bool Round::SystemGetRegistryResponse::setRegistry(const Registry reg) {
  JSONDictionary *resultDict = nodeRes->getResultDict();
  if (!resultDict)
    return false;
  
  std::string sval;
  time_t tval;
  
  if (reg.getKey(&sval)) {
    resultDict->set(Registry::KEY, sval);
  }

  if (reg.getValue(&sval)) {
    resultDict->set(Registry::VALUE, sval);
  }

  if (reg.getTimestamp(tval)) {
    resultDict->set(Registry::TS, tval);
  }

  if (reg.getLogicalTimestamp(tval)) {
    resultDict->set(Registry::LTS, tval);
  }

  return true;
}
示例#17
0
文件: Frame.cpp 项目: samcake/hifi
FrameType Frame::registerFrameType(const QString& frameTypeName) {
    Locker lock(mutex);
    std::call_once(once, [&] {
        auto headerType = frameTypes.registerValue("com.highfidelity.recording.Header");
        Q_ASSERT(headerType == Frame::TYPE_HEADER);
    });
    return frameTypes.registerValue(frameTypeName);
}
示例#18
0
static void Domain(Registry& reg, string grp)
{
	string suffix = GetDomainSuffix<TDomain>();
	string tag = GetDomainTag<TDomain>();

	#ifdef UG_PARALLEL
		{
			typedef DomainBalanceWeights<TDomain, AnisotropicBalanceWeights<TDomain::dim> > T;
			string name = string("AnisotropicBalanceWeights").append(suffix);
			reg.add_class_<T, IBalanceWeights>(name, grp)
				.template add_constructor<void (*)(TDomain&)>()
				.add_method("set_weight_factor", &T::set_weight_factor)
				.add_method("weight_factor", &T::weight_factor)
				.set_construct_as_smart_pointer(true);
			reg.add_class_to_group(name, "AnisotropicBalanceWeights", tag);
		}

		{
			typedef BalanceWeightsLuaCallback<TDomain> T;
			string name = string("BalanceWeightsLuaCallback").append(suffix);
			reg.add_class_<T, IBalanceWeights>(name, grp)
				.template add_constructor<void (*)(SmartPtr<TDomain> spDom,
												   const char* luaCallbackName)>()
				.add_method("set_time", &T::set_time)
				.add_method("time", &T::time)
				.set_construct_as_smart_pointer(true);
			reg.add_class_to_group(name, "BalanceWeightsLuaCallback", tag);
		}

		{
			string name = string("DomainLoadBalancer").append(suffix);
			typedef DomainLoadBalancer<TDomain> T;
			typedef LoadBalancer TBase;
			reg.add_class_<T, TBase>(name, grp)
				.template add_constructor<void (*)(SmartPtr<TDomain>)>("Domain")
				.set_construct_as_smart_pointer(true);
			reg.add_class_to_group(name, "DomainLoadBalancer", tag);
		}

		reg.add_function("CreateProcessHierarchy",
						 static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
						 									size_t, size_t, int,
						 									int)>
						 	(&CreateProcessHierarchy<TDomain>),
						 grp, "ProcessHierarchy", "Domain, minNumElemsPerProcPerLvl, "
						 "maxNumRedistProcs, maxNumProcs, minDistLvl, "
						 "maxLvlsWithoutRedist");
		reg.add_function("CreateProcessHierarchy",
						 static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
						 									size_t, size_t, int,
						 									int, IRefiner*)>
						 	(&CreateProcessHierarchy<TDomain>),
						 grp, "ProcessHierarchy", "Domain, minNumElemsPerProcPerLvl, "
						 "maxNumRedistProcs, maxNumProcs, minDistLvl, "
						 "maxLvlsWithoutRedist, refiner");

	#endif
}
示例#19
0
		void ClassificationValidation::saveToFile(string filename, const double& quality_input_test, const double& predictive_quality) const
		{
			ofstream out(filename.c_str());
			
			Registry reg;
			out<<"# used quality statistic: "<<reg.getClassificationStatisticName(validation_statistic_)<<endl<<endl;
			out << "Fit to training data = "<<quality_input_test<<endl;
			out << "Predictive quality = "<<predictive_quality<<endl;	
		}
示例#20
0
void RegisterBridge_PCL(Registry& reg, string parentGroup)
{
	string grp(parentGroup);
	grp.append("/PCL");

	reg.add_function("DisableMPIInit", &DisableMPIInitDUMMY, grp, "", "",
	                 "Tells PCL to not call MPI_Init and MPI_Finalize.");

	reg.add_function("PclDebugBarrierEnabled", &PclDebugBarrierEnabledDUMMY, grp,
					"Enabled", "", "Returns the whether debug barriers are enabled.");

	reg.add_function("PclDebugBarrierAll", &PclDebugBarrierAllDUMMY, grp,
					 "", "", "Synchronizes all parallel processes if the executable"
							 "has been compiled with PCL_DEBUG_BARRIER=ON");

	reg.add_function("NumProcs", &NumProcsDUMMY, grp,
					"NumProcs", "", "Returns the number of active processes.");

	reg.add_function("ProcRank", &ProcRankDUMMY, grp,
					"ProcRank", "", "Returns the rank of the current process.");

	reg.add_function("SynchronizeProcesses", &SynchronizeProcessesDUMMY, grp,
					"", "", "Waits until all active processes reached this point.");

	reg.add_function("AllProcsTrue", &AllProcsTrueDUMMY, grp,
					 "boolean", "boolean", "Returns true if all processes call the method with true.");

	reg.add_function("ParallelMin", &ParallelMinDUMMY<double>, grp, "tmax", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelMax", &ParallelMaxDUMMY<double>, grp, "tmin", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
	reg.add_function("ParallelSum", &ParallelSumDUMMY<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");
}
示例#21
0
void initializeRotor( Registry & registry, const string & poseMessage )
{
  registry.registerType( ROTOR_DEFINITION_STRING( carmen_point_t ) );

  if ( poseMessage == "carmen_base_odometry" )
  {
    registry.registerMessageType(
      "carmen_base_odometry",
      ROTOR_DEFINITION_STRING( carmen_base_odometry_message )
    );
    registry.subscribeToMessage( "carmen_base_odometry", true );
  } else if ( poseMessage == "locfilter_filteredpos_message" ) {
    registry.registerMessageType(
      "locfilter_filteredpos_message",
      ROTOR_DEFINITION_STRING( locfilter_filteredpos_message )
    );
    registry.subscribeToMessage( "locfilter_filteredpos_message", true );
  }

  registry.registerMessageType(
    "axt_message",
    ROTOR_DEFINITION_STRING( axt_message )
  );
  registry.subscribeToMessage( "axt_message" );

  registry.registerType( ROTOR_DEFINITION_STRING( carmen_laser_laser_config_t ) );
  registry.registerMessageType(
    "carmen_robot_frontlaser",
    ROTOR_DEFINITION_STRING( carmen_robot_laser_message )
  );
}
示例#22
0
	//*************************************************************************
	// Method:		ConvertToFeatureDisabledTrial
	// Description: converts the functionality to a feature disabled trial
	//
	// Parameters:
	//	None
	//
	// Return Value: None
	//*************************************************************************
	void RegistrationMgr::ConvertToFeatureDisabledTrial()
	{
		Registry registry;

		if (!registry.OpenKey(ROOT_KEY, ROOT_PATH))
			return;

		registry.DeleteValue(SERIAL_NUMBER_VALUE_NAME);
		registry.DeleteValue(REGISTRATION_KEY_VALUE_NAME);

		ReloadRegistrationData();
	}
示例#23
0
void InputStackingOrderTest::init()
{
    using namespace KWayland::Client;
    // setup connection
    m_connection = new ConnectionThread;
    QSignalSpy connectedSpy(m_connection, &ConnectionThread::connected);
    QVERIFY(connectedSpy.isValid());
    m_connection->setSocketName(s_socketName);

    m_thread = new QThread(this);
    m_connection->moveToThread(m_thread);
    m_thread->start();

    m_connection->initConnection();
    QVERIFY(connectedSpy.wait());

    m_queue = new EventQueue(this);
    QVERIFY(!m_queue->isValid());
    m_queue->setup(m_connection);
    QVERIFY(m_queue->isValid());

    Registry registry;
    registry.setEventQueue(m_queue);
    QSignalSpy compositorSpy(&registry, &Registry::compositorAnnounced);
    QSignalSpy shmSpy(&registry, &Registry::shmAnnounced);
    QSignalSpy shellSpy(&registry, &Registry::shellAnnounced);
    QSignalSpy seatSpy(&registry, &Registry::seatAnnounced);
    QSignalSpy allAnnounced(&registry, &Registry::interfacesAnnounced);
    QVERIFY(allAnnounced.isValid());
    QVERIFY(shmSpy.isValid());
    QVERIFY(shellSpy.isValid());
    QVERIFY(compositorSpy.isValid());
    QVERIFY(seatSpy.isValid());
    registry.create(m_connection->display());
    QVERIFY(registry.isValid());
    registry.setup();
    QVERIFY(allAnnounced.wait());
    QVERIFY(!compositorSpy.isEmpty());
    QVERIFY(!shmSpy.isEmpty());
    QVERIFY(!shellSpy.isEmpty());
    QVERIFY(!seatSpy.isEmpty());

    m_compositor = registry.createCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>(), this);
    QVERIFY(m_compositor->isValid());
    m_shm = registry.createShmPool(shmSpy.first().first().value<quint32>(), shmSpy.first().last().value<quint32>(), this);
    QVERIFY(m_shm->isValid());
    m_shell = registry.createShell(shellSpy.first().first().value<quint32>(), shellSpy.first().last().value<quint32>(), this);
    QVERIFY(m_shell->isValid());
    m_seat = registry.createSeat(seatSpy.first().first().value<quint32>(), seatSpy.first().last().value<quint32>(), this);
    QVERIFY(m_seat->isValid());
    QSignalSpy hasPointerSpy(m_seat, &Seat::hasPointerChanged);
    QVERIFY(hasPointerSpy.isValid());
    QVERIFY(hasPointerSpy.wait());

    screens()->setCurrent(0);
    Cursor::setPos(QPoint(640, 512));
}
void VKUAuthConfig::Read() {
	String regPath(VKUApp::GetInstance()->GetAppDataPath() + L"auth.ini");
	String authSection(L"auth");
	Registry reg;
	reg.Construct(regPath, false);
	if(accessTokenValue != null) {
		delete accessTokenValue;
	}
	accessTokenValue = new String();
	reg.GetValue(authSection, "access_token", *accessTokenValue);
	reg.GetValue(authSection, "expires_in", expiresInValue);
	reg.GetValue(authSection, "user_id", userIdValue);
}
示例#25
0
TEST_F(TestProperties, TestBuilder)
{
	Registry R;
	R.AddClass<int>();
	R.AddClass<Vector>();

	ClassBuilder<PropTest>(R)
		.Methods
		.Properties
			("num", &PropTest::num)
			("p_num", &PropTest::p_num)
			("object", &PropTest::object)
		;
	Pointer<PropTest> prop_test = R.New<PropTest>();
	ASSERT_TRUE(prop_test);
	ClassBase const *klass = prop_test.GetClass();
	ASSERT_TRUE(klass->HasProperty("num"));
	ASSERT_TRUE(klass->HasProperty("p_num"));
	ASSERT_TRUE(prop_test.Has("num"));
	ASSERT_FALSE(prop_test.Has("p_num"));

	Pointer<int> N1 = R.New(123);
	Pointer<int> N2 = R.New(456);
	Pointer<int> N3 = R.New(789);

	ASSERT_FALSE(N1.HasParent());
	prop_test->p_num = N1;
	ASSERT_TRUE(N1.HasParent());
	ASSERT_TRUE(N1.GetParentHandle() == prop_test.GetHandle());
	
	prop_test.Set("num", N2);
	ASSERT_TRUE(prop_test->num == *N2);
	ASSERT_FALSE(N2.HasParent());
	prop_test.SetValue("num", 666);
	ASSERT_TRUE(prop_test->num == 666);
	ASSERT_FALSE(N2.HasParent());


	ASSERT_TRUE(N1.HasParent());
	ASSERT_FALSE(N3.HasParent());
	prop_test.Set("p_num", N3);
	ASSERT_FALSE(N1.HasParent());
	ASSERT_TRUE(N3.HasParent());
	ASSERT_TRUE(N3.GetParentHandle() == prop_test.GetHandle());

	prop_test.SetValue("p_num", 42);
	EXPECT_EQ(*N3, 42);

	prop_test.SetValue("num", 13);
	EXPECT_EQ(prop_test->num, 13);
}
示例#26
0
bool RegisterSerializationCommands(Registry &reg, const char* parentGroup)
{
	stringstream grpSS; grpSS << parentGroup << "/Serialization";
	std::string grp = grpSS.str();

	try
	{
//		reg.add_function("LuaList_writeObjects", &LuaList_writeObjects, grp.c_str());
		reg.add_function("LuaWrite", &LuaWrite, grp.c_str());
		reg.add_function("LuaWriteCout", &LuaWriteCout, grp.c_str());
	}
	UG_REGISTRY_CATCH_THROW(grp);

	return true;
}
示例#27
0
bool DestroyWindow()
{
	Registry		reg;
	WINDOWPLACEMENT wp;

	// Save window position
	reg.read_reg();
	GetWindowPlacement(g_hWnd, &wp);

	reg.main_x = wp.rcNormalPosition.left;
	reg.main_y = wp.rcNormalPosition.top;
	reg.write_reg();

	return true;
}
STDAPI DllRegisterServer()
{ HRESULT hr         = S_OK;
  LPCTSTR prodPrefix = NULL;
  LPCTSTR compPrefix = NULL;
  TCHAR   szModulePath[MAX_PATH];

  COMServer::GetModuleFileName(szModulePath,sizeof(szModulePath)/sizeof(szModulePath[0]));

  VersionInfo verInfo(szModulePath);

  prodPrefix = (LPCTSTR)verInfo.GetStringInfo(_T("ProductPrefix"));
  compPrefix = (LPCTSTR)verInfo.GetStringInfo(_T("ComponentPrefix"));

  try
  { Registry registry;

    RegistryUtil::RegisterComObjectsInTypeLibrary(registry,szModulePath,RegistryUtil::AUTO);

    if( registry.Prepare() )
      registry.Commit();

/*
    as marker for registration of multiple typelibs

    RegistryUtil::RegisterTypeLib(LIBID_BVR20983_1_SC,LANG_SYSTEM_DEFAULT,_T("1"),1,0,szModulePath,szWindowsDir);
    RegistryUtil::RegisterTypeLib(LIBID_BVR20983_1_SC,MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_NEUTRAL), SORT_DEFAULT),_T("2"),1,0,szModulePath,szWindowsDir);
*/
  }
  catch(BVR20983Exception e)
  { LOGGER_ERROR<<e<<endl;

    hr = SELFREG_E_CLASS;
  }
  catch(exception& e) 
  { LOGGER_ERROR<<"Exception "<<typeid(e).name()<<":"<<e.what()<<endl;

    hr = SELFREG_E_CLASS;
  }
  catch(...)
  { LOGGER_ERROR<<_T("Exception")<<endl;

    hr = SELFREG_E_CLASS;
  }

  EvtLogInstall(NULL!=prodPrefix ? prodPrefix : _T("unknown"),NULL!=compPrefix ? compPrefix : _T("unknown"),TRUE,hr);

  return hr;
} // of DllRegisterServer()
示例#29
0
string deriveSecret(string job, Registry registry)
{

    // get the master secret value from the registry
    byte* master = (byte*) (registry.find("master")->second).c_str();

    // Generate the salt
    byte* salt = generateRandomSalt(DEFAULT_SALT_SIZE);

    // Derivate the key
    byte* okm = deriveKey(256, (byte*) master, 256, salt, 256);

    cout << "salt" << endl << salt << endl << endl;
    cout << "okm" << endl << okm << endl << endl;
    cout << "master" << endl << master << endl << endl;

    // return the OKM and the salt XXX check that sizeof is doing what's
    // intended
    Response resp;
    resp.set_salt(&salt, 256);
    resp.set_secret(&okm, 256);

    string string_resp;
    resp.SerializeToString(&string_resp);
    return string_resp;
}
示例#30
0
/**
 * Reads the master secret and put it in the registry
 *
 * @param Registry reg the registry to use
 * @returns void
 **/
void readMasterSecret(Registry reg)
{
    string master = (char*) readFile("master");

    pair <string, string> master_pair = pair <string, string>("master", master);
    reg.insert(master_pair);
}