Ref<Image> Image::load_from_data (const Ptr<IData> data) { static Stopwatch t; static unsigned count = 0; ++count; Ref<Image> loaded_image; Shared<Buffer> buffer; t.start(); buffer = data->buffer(); switch (buffer->mimetype()) { case IMAGE_JPEG: loaded_image = load_jpeg_image(data); break; case IMAGE_PNG: loaded_image = load_png_image(data); break; //case Data::IMAGE_DDS: // loaded_image = load_ddsimage(data); default: logger()->log(LOG_ERROR, "Could not load image: Unsupported image format."); } t.pause(); logger()->log(LOG_INFO, LogBuffer() << "*** Total time to load " << count << " images: " << t.time() << "s"); return loaded_image; }
void ns2ClassA_memberFunction_9(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { typedef boost::shared_ptr<ns2::ClassA> Shared; checkArguments("memberFunction",nargout,nargin-1,0); Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA"); out[0] = wrap< double >(obj->memberFunction()); }
CC_FILE_ERROR FileIOFilter::SaveToFile( ccHObject* entities, const QString& filename, SaveParameters& parameters, Shared filter) { if (!entities || filename.isEmpty() || !filter) return CC_FERR_BAD_ARGUMENT; //if the file name has no extension, we had a default one! QString completeFileName(filename); if (QFileInfo(filename).suffix().isEmpty()) completeFileName += QString(".%1").arg(filter->getDefaultExtension()); CC_FILE_ERROR result = CC_FERR_NO_ERROR; try { result = filter->saveToFile(entities, completeFileName, parameters); } catch(...) { ccLog::Warning(QString("[I/O] CC has caught an unhandled exception while saving file '%1'").arg(filename)); result = CC_FERR_CONSOLE_ERROR; } if (result == CC_FERR_NO_ERROR) { ccLog::Print(QString("[I/O] File '%1' saved successfully").arg(filename)); } else { DisplayErrorMessage(result,"saving",filename); } return result; }
int main() { Shared<Car> a; auto age1 = a.execute([](Car & c) -> unsigned { return c.increment_age(); }); auto age2 = a.execute([](Car & c) -> unsigned { return c.increment_age(); }); auto age3 = a.execute([](Car & c) -> unsigned { return c.increment_age(); }); std::cout << age1.get() << ", " << age2.get() << ", " << age3.get() << std::endl; }
void ns2ClassA_nsArg_10(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { typedef boost::shared_ptr<ns2::ClassA> Shared; checkArguments("nsArg",nargout,nargin-1,1); Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA"); ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ptr_ns1ClassB"); out[0] = wrap< int >(obj->nsArg(arg)); }
/// Create a buffer from a given input stream BufferedData::BufferedData (std::istream & stream) { Shared<DynamicBuffer> buffer = new DynamicBuffer; buffer->append(std::istreambuf_iterator<char>(stream), std::istreambuf_iterator<char>()); _buffer = buffer; }
void ns2ClassA_nsReturn_11(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { typedef boost::shared_ptr<ns2::ns3::ClassB> SharedClassB; typedef boost::shared_ptr<ns2::ClassA> Shared; checkArguments("nsReturn",nargout,nargin-1,1); Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA"); double q = unwrap< double >(in[1]); out[0] = wrap_shared_ptr(SharedClassB(new ns2::ns3::ClassB(obj->nsReturn(q))),"ns2.ns3.ClassB", false); }
void Dictionary::deserialize (Ref<IData> data) { Shared<Buffer> buffer = data->buffer(); std::size_t offset = 0; while (offset < buffer->size()) { KeyT key = TypeSerialization<TI_STRING>::read_from_buffer(*buffer, offset); _values[key] = Value::read_from_buffer(*buffer, offset); } }
static Ref<Image> load_jpeg_image (const Ptr<IData> data) { jpeg_decompress_struct cinfo; jpeg_error_mgr jerr; Ref<Image> result_image; DataType data_type = DataType::BYTE; Shared<Buffer> buffer = data->buffer(); unsigned width, height; try { //memset (&cinfo, 0, sizeof (cinfo)); memset (&jerr, 0, sizeof (jerr)); cinfo.err = jpeg_std_error(&jerr); jpeg_create_decompress(&cinfo); jpeg_memory_src(&cinfo, buffer->begin(), buffer->size()); jpeg_read_header(&cinfo, TRUE); width = cinfo.image_width; height = cinfo.image_height; unsigned row_width = 0; PixelFormat pixel_format; if (cinfo.jpeg_color_space == JCS_GRAYSCALE) { row_width = width; pixel_format = PixelFormat::L; } else { row_width = 3 * width; pixel_format = PixelFormat::RGB; } result_image = new Image(Vec2u(width, height), pixel_format, data_type); ByteT *line = result_image->data(); jpeg_start_decompress(&cinfo); // read jpeg image while (cinfo.output_scanline < cinfo.output_height) { jpeg_read_scanlines(&cinfo, &line, 1); line += row_width; } jpeg_finish_decompress(&cinfo); jpeg_destroy_decompress(&cinfo); } catch (std::exception &e) { } return result_image; };
Ref<Object> Sound::Loader::load_from_data (const Ptr<IData> data, const ILoader * loader) { Shared<Buffer> buffer = data->buffer(); Mimetype mt = buffer->mimetype(); if (mt == AUDIO_XWAV) { return load_wave_data(data); } else { throw LoadError("Could not load audio data"); } }
int main() { Shared shlib; Static stlib; std::cout << "Static library subtract(5, 3): "; std::cout << stlib.subtract(5, 3) << std::endl; std::cout << "Shared library add(4, 5): "; std::cout << shlib.add(4, 5) << std::endl; return EXIT_SUCCESS; }
Shared<Buffer> Program::info_log() { GLint length; property(GL_INFO_LOG_LENGTH, &length); if (length > 0) { Shared<MutableBuffer> buffer = PackedBuffer::new_buffer(length); glGetProgramInfoLog(_handle, length, NULL, (GLchar *)buffer->begin()); return buffer; } else { return NULL; } }
Shared<ui::Font> FontAsset::createFont() const { Shared<Texture2D> atlasTex = Shared<Texture2D>::alloc(); atlasTex->alloc(); atlasTex->set_texels(atlas, 0); return Shared<ui::Font>::alloc( std::move(atlasTex), entries, defaultEntry, lineHeight, tabWidth, spaceWidth); }
void init( const Shared & shared, const Group & group, rng_t & rng) { Shared post = shared.plus_group(group); mean = sample_gamma(rng, post.alpha, 1.f / post.inv_beta); }
Future<bool> CoordinatorProcess::checkLearnPhase(const Action& action) { // Make sure that the local replica has learned the newly written // log entry. Since messages are delivered and dispatched in order // locally, we should always have the new entry learned by now. return replica->missing(action.position()); }
void init( const Shared & shared, const Group & group, rng_t & rng) { Shared post = shared.plus_group(group); beta = sample_beta(rng, post.alpha, post.beta); }
void setupMappings() { char key[256]; if (getpid() != MEMSRV_PID) { /* Load the mounts and process table. */ mounts.load(FILE_SYSTEM_MOUNT_KEY, MAX_MOUNTS); procs.load(USER_PROCESS_KEY, MAX_PROCS); /* Format FileDescriptor key. */ snprintf(key, sizeof(key), "%s%u", FILE_DESCRIPTOR_KEY, getpid()); /* Then load the FileDescriptor table. */ files.load(key, FILE_DESCRIPTOR_MAX); } }
foreach (Owned<Plugin> _plugin, plugins) { Shared<Plugin> plugin = _plugin.share(); if (pluginsByName.contains(plugin->name())) { LOG(WARNING) << "Multiple URI fetcher plugins register " << "under name '" << plugin->name() << "'"; } pluginsByName[plugin->name()] = plugin; foreach (const string& scheme, plugin->schemes()) { if (pluginsByScheme.contains(scheme)) { LOG(WARNING) << "Multiple URI fetcher plugins register " << "URI scheme '" << scheme << "'"; } pluginsByScheme[scheme] = plugin; } }
float score_data( const Shared & shared, rng_t &) const { Shared post = shared.plus_group(*this); float score = fast_lgamma(shared.alpha + shared.beta) - fast_lgamma(post.alpha + post.beta); score += fast_lgamma(post.alpha) - fast_lgamma(shared.alpha); score += fast_lgamma(post.beta) - fast_lgamma(shared.beta); return score; }
float score_data( const Shared & shared, rng_t &) const { Shared post = shared.plus_group(*this); float score = fast_lgamma(post.alpha) - fast_lgamma(shared.alpha); score += shared.alpha * fast_log(shared.inv_beta) - post.alpha * fast_log(post.inv_beta); score += -log_prod; return score; }
void init( const Shared & shared, const Group & group, rng_t &) { Shared post = shared.plus_group(group); score_coeff = -fast_log(1.f + post.inv_beta); score = -fast_lgamma(post.alpha) + post.alpha * (fast_log(post.inv_beta) + score_coeff); post_alpha = post.alpha; }
void FileIOFilter::Register(Shared filter) { if (!filter) { assert(false); return; } //filters are uniquely recognized by their 'file filter' string QStringList fileFilters = filter->getFileFilters(true); QString filterName = filter->getDefaultExtension().toUpper(); for (FilterContainer::const_iterator it=s_ioFilters.begin(); it!=s_ioFilters.end(); ++it) { bool error = false; if (*it == filter) { ccLog::Warning(QString("[FileIOFilter::Register] I/O filter '%1' is already registered").arg(filterName)); error = true; } else { //we are going to compare the file filters as they should remain unique! QStringList otherFilters = (*it)->getFileFilters(true); for (int i=0; i<fileFilters.size(); ++i) { if (otherFilters.contains(fileFilters[i])) { QString otherFilterName = (*it)->getDefaultExtension().toUpper();; ccLog::Warning(QString("[FileIOFilter::Register] Internal error: file filter '%1' of filter '%2' is already handled by another filter ('%3')!").arg(fileFilters[i]).arg(filterName).arg(otherFilterName)); error = true; break; } } } if (error) return; } //insert filter s_ioFilters.push_back(filter); }
bool Program::link() { glLinkProgram(_handle); GLint status; property(GL_LINK_STATUS, &status); glGetProgramiv(_handle, GL_LINK_STATUS, &status); if (status == 0) { // Something went wrong... Shared<Buffer> log = info_log(); LogBuffer buffer; buffer << "Error linking program:" << std::endl; buffer << StringT(log->begin(), log->end()) << std::endl; logger()->log(LOG_ERROR, buffer); } return status != 0; }
void init( const Shared & shared, const Group & group, rng_t &) { Shared post = shared.plus_group(group); post_beta = post.beta; alpha = post.alpha + shared.r; score = fast_lgamma(post.alpha + post.beta) - fast_lgamma(post.alpha) - fast_lgamma(post.beta) + fast_lgamma(alpha); }
TEST(OwnedTest, Share) { Foo* foo = new Foo(); foo->set(42); Owned<Foo> owned(foo); EXPECT_EQ(42, owned->get()); EXPECT_EQ(42, (*owned).get()); EXPECT_EQ(42, owned.get()->get()); Shared<Foo> shared = owned.share(); EXPECT_EQ(NULL, owned.get()); EXPECT_TRUE(shared.unique()); EXPECT_EQ(42, shared->get()); EXPECT_EQ(42, (*shared).get()); EXPECT_EQ(42, shared.get()->get()); { Shared<Foo> shared2(shared); EXPECT_EQ(42, shared2->get()); EXPECT_EQ(42, (*shared2).get()); EXPECT_EQ(42, shared2.get()->get()); EXPECT_FALSE(shared.unique()); EXPECT_FALSE(shared2.unique()); } EXPECT_TRUE(shared.unique()); }
GLenum ShaderManager::compile(GLenum type, const Buffer * buffer) { GLuint shader = glCreateShader(type); const GLchar * source = (GLchar*)buffer->begin(); GLint length = (GLint)buffer->size(); glShaderSource(shader, 1, &source, &length); check_graphics_error(); glCompileShader(shader); check_graphics_error(); GLint log_length; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length); if (log_length > 0) { Shared<MutableBuffer> buffer = PackedBuffer::new_buffer(log_length); glGetShaderInfoLog(shader, (GLsizei)buffer->size(), (GLsizei*)&log_length, (GLchar*)buffer->begin()); LogBuffer log_buffer; log_buffer << "Error compiling shader:" << std::endl; log_buffer << buffer->begin() << std::endl; logger()->log(LOG_ERROR, log_buffer); } GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == 0) { logger()->log(LOG_ERROR, "Shader compilation failed!"); glDeleteShader(shader); return 0; } check_graphics_error(); return shader; }
float score_value( const Shared & shared, const Value & value, rng_t &) const { Shared post = shared.plus_group(*this); float alpha = post.alpha + shared.r; float beta = post.beta + value; float score = fast_lgamma(post.alpha + post.beta) - fast_lgamma(alpha + beta); score += fast_lgamma(alpha) - fast_lgamma(post.alpha); score += fast_lgamma(beta) - fast_lgamma(post.beta); return score; }
float score_data( const Shared & shared, const std::vector<Group> & groups, rng_t &) const { const float alpha_part = fast_lgamma(shared.alpha); const float beta_part = shared.alpha * fast_log(shared.inv_beta); float score = 0; for (auto const & group : groups) { if (group.count) { Shared post = shared.plus_group(group); score += fast_lgamma(post.alpha) - alpha_part; score += beta_part - post.alpha * fast_log(post.inv_beta); score += -group.log_prod; } } return score; }
float score_data( const Shared & shared, const std::vector<Group> & groups, rng_t &) const { const float shared_part = fast_lgamma(shared.alpha + shared.beta) - fast_lgamma(shared.alpha) - fast_lgamma(shared.beta); float score = 0; for (auto const & group : groups) { if (group.count) { Shared post = shared.plus_group(group); score += fast_lgamma(post.alpha) + fast_lgamma(post.beta) - fast_lgamma(post.alpha + post.beta); score += shared_part; } } return score; }
const char * read_bytes (unsigned length) { unsigned prev_offset = offset; offset += length; return (const char*)(buffer->begin() + prev_offset); }