//-----------------------------------------------------------------------------------------
//
bool joystick::initialize(const input_device_desc& desc) {
NYX_ASSERT(pimpl_ != nullptr);
if (is_initialized()) {
return is_initialized();
}
pimpl_->initialize((HWND)desc.handle, desc.range, desc.button);
return pimpl_->isInitialized;
}
bool keyboard::initialize(const input_device_desc& desc) {
NYX_ASSERT(pimpl_ != nullptr);
if (is_initialized()) {
return is_initialized();
}
pimpl_->initialize((HWND)desc.handle);
return pimpl_->isInitialized;
}
void ARVRInterface::set_is_initialized(bool p_initialized) {
if (p_initialized) {
if (!is_initialized()) {
initialize();
};
} else {
if (is_initialized()) {
uninitialize();
};
};
};
void push_back(value_type const& item)
{
if (!is_initialized(items_[0]))
{
items_[0] = item;
}
else if (!is_initialized(items_[1]))
{
items_[1] = item;
}
else
{
BOOST_ASSERT(false);
}
}
/**
* @brief Loads and decodes all sounds listed in the game database.
*/
void Sound::load_all() {
if (is_initialized()) {
// open the resource database file
const std::string file_name = "project_db.dat";
std::istream& database_file = FileTools::data_file_open(file_name);
std::string line;
// read each animation
while (std::getline(database_file, line)) {
if (line.size() == 0) {
continue;
}
int resource_type;
std::string resource_id, resource_name;
std::istringstream iss(line);
FileTools::read(iss, resource_type);
FileTools::read(iss, resource_id);
FileTools::read(iss, resource_name);
if (resource_type == 4) { // it's a sound
if (all_sounds.count(resource_id) == 0) {
all_sounds[resource_id] = Sound(resource_id);
all_sounds[resource_id].load();
}
}
}
FileTools::data_file_close(database_file);
}
}
/**
* @brief Closes the audio (music and sound) system.
*
* This method should be called when exiting the application.
*/
void Sound::quit() {
if (is_initialized()) {
/*
// stop the sound sources
ALuint source;
std::list<ALuint>::iterator it;
for (it = all_sources.begin(); it != all_sources.end(); it++) {
source = (*it);
alSourcei(source, AL_BUFFER, 0);
alDeleteSources(1, &source);
}
*/
// uninitialize the music subsystem
Music::quit();
// clear the sounds
all_sounds.clear();
// uninitialize OpenAL
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
context = NULL;
alcCloseDevice(device);
device = NULL;
initialized = false;
}
}
void Comm::finalize()
{
if( is_initialized() && !is_finalized() ) // then finalized
{
MPI_CHECK_RESULT(MPI_Finalize,());
// CFinfo << "MPI (version " << version() << ") -- finalized" << CFendl;
}
bool Opl2::generate(
const int count,
std::int16_t* buffer)
{
if (!is_initialized())
{
return false;
}
if (count < 1)
{
return false;
}
if (!buffer)
{
return false;
}
auto remain_count = count;
while (remain_count > 0)
{
const auto generate_count = std::min(remain_count, get_max_samples_count());
channel_.set_buffer(buffer);
emulator_.Generate(&channel_, static_cast<Bitu>(generate_count));
remain_count -= generate_count;
buffer += generate_count;
}
return true;
}
matlab_image_t matlab_image_t<T>::operator=(const matlab_engine_t other)
{
initialized_ = other.initialized_();
if (is_initialized())
initialize(other.get_const_array());
return *this;
}
std::future<std::vector<SpellDataPtr>> SpellData::GetGlobalSpells(
SpellDataListCallback success, APIFailureCallback failure)
{
return std::async(std::launch::async, [=]() -> std::vector<SpellDataPtr> {
APIRequestManager *manager = APIRequestManager::GetDefaultManager();
std::stringstream url;
url << "/spells/1";
std::string error;
auto response = manager->Send(url.str(), "GET", "", error);
if (response.is_initialized()) {
TSpellDataList items;
ParseSpellList(response.get(), items);
if (success) {
Dispatch::PushTask(Dispatch::MainQueue, [&items, success]() {
success(items);
});
}
return items;
}
else {
if (failure) {
Dispatch::PushTask(Dispatch::MainQueue, [&]() {
failure(error);
});
}
return std::vector<SpellDataPtr>();
}
});
}
void ThreadLocalStorage::init() {
assert(!is_initialized(),
"More than one attempt to initialize threadLocalStorage");
pd_init();
set_thread_index(os::allocate_thread_local_storage());
generate_code_for_get_thread();
}
int altix_lock_card(int fd, int id)
{
int cid = id;
if(!is_initialized()) return ALTIX_NOT_INITIALIZED;
if(ioctl(fd, ALTIX_IOCTL_LOCK, &cid) == 0)
{
#ifdef ALTIX_DEBUG
printf("libaltix: Locked %d \n", id);
#endif
return ALTIX_OK;
}
if(errno == EBUSY)
{
#ifdef ALTIX_DEBUG
printf("libaltix:Card %d already in use\n", id);
#endif
return ALTIX_CARD_BUSY;
}
else
{
#ifdef ALTIX_DEBUG
printf("libaltix: Could not find card with id %d\n", id);
#endif
return ALTIX_CARD_NOT_VALID;
}
}
void* altix_read_event(int fd, void* buff)
{
int error;
int allocated = 0;
int size = BEAM_TEST_EVENT_SIZE;
if(!is_initialized()) return 0;
if(buff == NULL)
{
allocated = 1;
buff = malloc(BEAM_TEST_EVENT_SIZE);
}
while(size > 0)
{
error = read(fd, (char*)buff + BEAM_TEST_EVENT_SIZE - size, size);
if(error <0)
{
#ifdef ALTIX_DEBUG
printf("Packet read failed with error %d. Is the card locked and DMA enabled?\n", error);
#endif
if(allocated)
free(buff);
return NULL;
}
size -=error;
}
return buff;
}
int altix_toggle_dma(int fd)
{
if(!is_initialized()) return ALTIX_NOT_INITIALIZED;
if(ioctl(fd, ALTIX_IOCTL_DMA) == 0)
return ALTIX_OK;
return ALTIX_CARD_NOT_VALID;
}
int altix_release_card(int fd, int id)
{
int cid = id;
if(!is_initialized()) return ALTIX_NOT_INITIALIZED;
if(ioctl(fd, ALTIX_IOCTL_RELEASE, &cid) == 0)
{
#ifdef ALTIX_DEBUG
printf("libaltix: unocked %d \n", id);
#endif
return ALTIX_OK;
}
if(errno == EBUSY)
{
#ifdef ALTIX_DEBUG
printf("libaltix:Card %d is not locked by this process\n", id);
#endif
return ALTIX_CARD_BUSY;
}
else
{
#ifdef ALTIX_DEBUG
printf("libaltix: Could not find card with id %d\n", id);
#endif
return ALTIX_CARD_NOT_VALID;
}
}
Status SocketEventSubscriber::Callback(const ECRef& ec, const SCRef&) {
if (ec->syscall == AUDIT_SYSCALL_CONNECT) {
if (ec->fields.count("exit") && ec->fields.at("exit") != "-115") {
// The connect syscall may want an exit with EINPROGRESS.
}
} else if (ec->type == AUDIT_TYPE_SYSCALL &&
ec->syscall != AUDIT_SYSCALL_BIND) {
return Status(0);
}
auto fields = asm_.add(ec->audit_id, ec->type, ec->fields);
if (ec->syscall == AUDIT_SYSCALL_CONNECT) {
asm_.set(ec->audit_id, "action", "connect");
} else if (ec->syscall == AUDIT_SYSCALL_BIND) {
asm_.set(ec->audit_id, "action", "bind");
}
if (fields.is_initialized()) {
if ((*fields)["action"] == "bind") {
(*fields)["local_port"] = std::move((*fields)["remote_port"]);
(*fields)["local_address"] = std::move((*fields)["remote_address"]);
}
add(*fields);
}
return Status(0);
}
void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
if (!is_initialized()) {
initialize();
}
// invoke compilation
#ifdef TIERED
// We are thread in native here...
CompilerThread* thread = CompilerThread::current();
{
ThreadInVMfromNative tv(thread);
MutexLocker only_one (C1_lock, thread);
while ( _compiling) {
C1_lock->wait();
}
_compiling = true;
}
#endif // TIERED
{
// We are nested here because we need for the destructor
// of Compilation to occur before we release the any
// competing compiler thread
ResourceMark rm;
Compilation c(this, env, method, entry_bci);
}
#ifdef TIERED
{
ThreadInVMfromNative tv(thread);
MutexLocker only_one (C1_lock, thread);
_compiling = false;
C1_lock->notify();
}
#endif // TIERED
}
const std::string& osqueryHomeDirectory() {
static std::string homedir;
if (homedir.size() == 0) {
// Try to get the caller's home directory
boost::system::error_code ec;
auto userdir = getHomeDirectory();
if (userdir.is_initialized() && isWritable(*userdir).ok()) {
auto osquery_dir = (fs::path(*userdir) / ".osquery");
if (isWritable(osquery_dir) ||
boost::filesystem::create_directories(osquery_dir, ec)) {
homedir = osquery_dir.make_preferred().string();
return homedir;
}
}
// Fail over to a temporary directory (used for the shell).
auto temp =
fs::temp_directory_path(ec) / fs::unique_path("osquery%%%%%%%%", ec);
boost::filesystem::create_directories(temp, ec);
homedir = temp.make_preferred().string();
}
return homedir;
}
QueryData genScheduledTasks(QueryContext& context) {
QueryData results;
// First process all tasks in the root folder
enumerateTasksForFolder("\\", results);
// We attempt to derive the location of the tasks folder
auto sysRoot = getEnvVar("SystemRoot");
if (!sysRoot.is_initialized()) {
return results;
}
auto sysTaskPath = *sysRoot + "\\System32\\Tasks";
// Then process all tasks in subsequent folders
std::vector<std::string> taskPaths;
listDirectoriesInDirectory(sysTaskPath, taskPaths, true);
for (const auto& path : taskPaths) {
if (sysTaskPath.size() >= path.size()) {
VLOG(1) << "Invalid task path " << path;
continue;
}
auto taskPath =
"\\" + join(split(path.substr(sysTaskPath.size(),
(path.size() - sysTaskPath.size())),
"\\"),
"\\");
enumerateTasksForFolder(taskPath, results);
}
return results;
}
/**
* @brief Exits the music system.
*/
void Music::quit() {
if (is_initialized()) {
delete spc_decoder;
delete it_decoder;
all_musics.clear();
}
}
QueryData genChocolateyPackages(QueryContext& context) {
QueryData results;
auto chocoEnvInstall = getEnvVar("ChocolateyInstall");
fs::path chocoInstallPath;
if (chocoEnvInstall.is_initialized()) {
chocoInstallPath = fs::path(*chocoEnvInstall);
}
if (chocoInstallPath.empty()) {
LOG(WARNING) << "Did not find chocolatey path environment variable";
return results;
}
auto nuspecPattern = chocoInstallPath / "lib/%/%.nuspec";
std::vector<std::string> manifests;
resolveFilePattern(nuspecPattern, manifests, GLOB_FILES);
for (const auto& pkg : manifests) {
Row r;
auto s = genPackage(pkg, r);
if (!s.ok()) {
VLOG(1) << "Failed to parse " << pkg << " with " << s.getMessage();
}
results.push_back(r);
}
return results;
}
/**
* @brief Creates a new music.
* @param music_id id of the music (a file name)
*/
Music::Music(const MusicId& music_id):
id(music_id) {
if (!is_initialized() || music_id == none) {
return;
}
// compute the file name
file_name = (std::string) "musics/" + music_id;
// get the format
size_t index = music_id.find_last_of(".");
Debug::check_assertion(index != std::string::npos && index != music_id.size(),
StringConcat() << "Invalid music file name: " << music_id);
std::string extension = music_id.substr(index + 1);
if (extension == "spc" || extension == "SPC" || extension == "Spc") {
format = SPC;
}
else if (extension == "it" || extension == "IT" || extension == "It") {
format = IT;
}
else if (extension == "ogg" || extension == "OGG" || extension == "Ogg") {
format = OGG;
}
else {
Debug::die(StringConcat() << "Unrecognized music file format: " << music_id);
}
for (int i = 0; i < nb_buffers; i++) {
buffers[i] = AL_NONE;
}
source = AL_NONE;
}
_nes_rom::~_nes_rom(void)
{
if(is_initialized()) {
uninitialize();
}
}
/* checks if a vector is a feasible point of the LP */
int is_Solution(bip inst, int* test){
assert(is_initialized(inst));
for (int i=0; i<inst.rows; ++i){
if (scalar_product(get_elem(inst, i, 0),test, inst.columns)>inst.vector[i]) return 0;
}
return 1;
}
bool PureClientContext::m_connectCallbacksOnPath(std::string const &path) {
/// Start by removing handler from interface tree and handler container
/// for this path, if found. Ensures that if we early-out (fail to set
/// up a handler) we don't have a leftover one still active.
m_interfaces.eraseHandlerForPath(path);
auto source = common::resolveTreeNode(m_pathTree, path);
if (!source.is_initialized()) {
OSVR_DEV_VERBOSE("Could not resolve source for " << path);
return false;
}
auto handler = m_factory.invokeFactory(
*source, m_interfaces.getInterfacesForPath(path), *this);
if (handler) {
OSVR_DEV_VERBOSE("Successfully produced handler for " << path);
// Store the new handler in the interface tree
auto oldHandler = m_interfaces.replaceHandlerForPath(path, handler);
BOOST_ASSERT_MSG(
!oldHandler,
"We removed the old handler before so it should be null now");
return true;
}
OSVR_DEV_VERBOSE("Could not produce handler for " << path);
return false;
}
bool IterQuantityAccessContiguous<T_info>::updated_k(int offset) const {
if( !is_initialized() )
return false;
if( ( offset > max_offset_ ) || ( offset < max_offset_ - num_quantities_ + 1 ) )
return false;
return updated_[max_offset_ - offset];
}
inline
void ExampleNLPFirstOrder::assert_is_initialized() const
{
typedef NLPInterfacePack::NLP NLP;
if( !is_initialized() )
throw NLP::UnInitialized("ExampleNLPFirstOrder::assert_is_initialized() : Error, "
"ExampleNLPFirstOrder::initialize() has not been called yet." );
}
/**
* \brief Exits the music system.
*/
void Music::quit() {
if (is_initialized()) {
current_music = nullptr;
spc_decoder = nullptr;
it_decoder = nullptr;
}
}
TEST_F(ProcessTests, test_envVar) {
auto val = getEnvVar("GTEST_OSQUERY");
EXPECT_FALSE(val);
EXPECT_FALSE(val.is_initialized());
EXPECT_TRUE(setEnvVar("GTEST_OSQUERY", "true"));
val = getEnvVar("GTEST_OSQUERY");
EXPECT_FALSE(!val);
EXPECT_TRUE(val.is_initialized());
EXPECT_EQ(*val, "true");
EXPECT_TRUE(unsetEnvVar("GTEST_OSQUERY"));
val = getEnvVar("GTEST_OSQUERY");
EXPECT_FALSE(val);
EXPECT_FALSE(val.is_initialized());
}
int is_Solution_eq(bip inst, int* test){
if (!is_initialized(inst)) {
return 0;
}
for (int i=0; i<inst.rows; ++i){
if (scalar_product(get_elem(inst, i, 0),test, inst.columns)!=inst.vector[i]) return 0;
}
return 1;
}
