void ChromeClientBlackBerry::runOpenPanel(WebCore::Frame*, WTF::PassRefPtr<WebCore::FileChooser> chooser) { SharedArray<WebString> initialFiles; unsigned int initialFileSize = chooser->filenames().size(); if (initialFileSize > 0) initialFiles.reset(new WebString[initialFileSize]); for (unsigned i = 0; i < initialFileSize; ++i) initialFiles[i] = chooser->filenames()[i]; SharedArray<WebString> chosenFiles; unsigned int chosenFileSize; { PageGroupLoadDeferrer deferrer(m_webPage->d->m_page, true); TimerBase::fireTimersInNestedEventLoop(); if (!m_webPage->client()->chooseFilenames(chooser->allowsMultipleFiles(), chooser->acceptTypes(), initialFiles, initialFileSize, chosenFiles, chosenFileSize)) return; } Vector<WTF::String> files(chosenFileSize); for (unsigned i = 0; i < chosenFileSize; ++i) files[i] = chosenFiles[i]; chooser->chooseFiles(files); }
void ChromeClientBlackBerry::runOpenPanel(Frame*, PassRefPtr<FileChooser> chooser) { SharedArray<WebString> initialFiles; unsigned int initialFileSize = chooser->settings().selectedFiles.size(); if (initialFileSize > 0) initialFiles.reset(new WebString[initialFileSize]); for (unsigned i = 0; i < initialFileSize; ++i) initialFiles[i] = chooser->settings().selectedFiles[i]; SharedArray<WebString> chosenFiles; unsigned int chosenFileSize; { PageGroupLoadDeferrer deferrer(m_webPagePrivate->m_page, true); TimerBase::fireTimersInNestedEventLoop(); // FIXME: Use chooser->settings().acceptMIMETypes instead of WebString() for the second parameter. if (!m_webPagePrivate->m_client->chooseFilenames(chooser->settings().allowsMultipleFiles, WebString(), initialFiles, initialFileSize, chosenFiles, chosenFileSize)) return; } Vector<String> files(chosenFileSize); for (unsigned i = 0; i < chosenFileSize; ++i) files[i] = chosenFiles[i]; chooser->chooseFiles(files); }
bool BspSceneFile::loadBspDirEntry(std::istream& bspStream, const Q3Bsp::DirEntry& entry, SharedArray<uint8_t>::Type& outData) { if (!bspStream.seekg(entry.offset, std::ios::beg)) { return false; } outData.reset(new uint8_t[entry.length]); if (!bspStream.read(reinterpret_cast<char*>(outData.get()), entry.length)) { return false; } return true; }
void RendererService::updateCamPosition(SharedArray positionValue, SharedArray focalValue, SharedArray viewUpValue) { vtkCamera* camera = m_render->GetActiveCamera(); camera->SetPosition(positionValue.get()); camera->SetFocalPoint(focalValue.get()); camera->SetViewUp(viewUpValue.get()); camera->SetClippingRange(0.1, 1000000); m_interactorManager->getInteractor()->Render(); }
inline ExecStatus Weights<View>::post(Home home, const SharedArray<int>& elements, const SharedArray<int>& weights, View x, Gecode::Int::IntView y) { if (elements.size() != weights.size()) throw ArgumentSizeMismatch("Weights"); Region r(home); int* els_arr = r.alloc<int>(elements.size()); for (int i=elements.size(); i--;) els_arr[i] = elements[i]; IntSet els(els_arr, elements.size()); IntSetRanges er(els); GECODE_ME_CHECK(x.intersectI(home, er)); (void) new (home) Weights(home,elements,weights,x,y); return ES_OK; }
bool Model::loadSTLFromStream(std::fstream &file, SharedArray vertexArray, SharedArray normalsArray) { int bufferSize = 80; char buffer[bufferSize]; if (file.readsome(buffer, bufferSize * sizeof(char)) != bufferSize) { return false; } unsigned int numberOfTriangles = 0; if (file.readsome((char *)&numberOfTriangles, sizeof(unsigned int)) != sizeof(unsigned int)) { return false; } vertexArray->resize(numberOfTriangles*9); normalsArray->resize(numberOfTriangles*3); STLTriangle triangle; for(unsigned int i = 0; i < numberOfTriangles; i++){ if(file.readsome((char *)&triangle.normal, sizeof(float)*3) != sizeof(float)*3){ return false; } if(file.readsome((char *)&triangle.vertex, sizeof(float)*9) != sizeof(float)*9){ return false; } if(file.readsome((char *)&triangle.attribute, sizeof(unsigned short)) != sizeof(unsigned short)){ return false; } for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { vertexArray->push_back(triangle.vertex[i][j]); } normalsArray->push_back(triangle.normal[i]); } } }
void RendererService::notifyCamPositionUpdated() { vtkCamera* camera = m_render->GetActiveCamera(); SharedArray position = SharedArray(new double[3]); SharedArray focal = SharedArray(new double[3]); SharedArray viewUp = SharedArray(new double[3]); std::copy(camera->GetPosition(), camera->GetPosition()+3, position.get()); std::copy(camera->GetFocalPoint(), camera->GetFocalPoint()+3, focal.get()); std::copy(camera->GetViewUp(), camera->GetViewUp()+3, viewUp.get()); fwServicesBlockAndNotifyMacro( this->getLightID(), m_sigCamUpdated, (position, focal, viewUp), m_slotUpdateCamPosition ); }
void CreateSharedBuffers( const int bytesPerBuffer ) { // setup shared memory buffers for ( int i = 0; i < constants::NUM_BUFFERS; ++i ) { // create unique buffer file names std::string bufferName = constants::BUFFER_BASE_NAME + boost::lexical_cast<string> ( i ) + ".buf"; // create shared buffers SharedBufferPtr bufPtr ( new SharedMemory ( bufferName, bytesPerBuffer, SHM::CreateShared, 0666 ) ); // store buffer in a vector array_.push_back ( bufPtr ); } }
void ChromeClientBlackBerry::runOpenPanel(Frame*, PassRefPtr<FileChooser> chooser) { SharedArray<BlackBerry::Platform::String> initialFiles; unsigned numberOfInitialFiles = chooser->settings().selectedFiles.size(); if (numberOfInitialFiles > 0) initialFiles.reset(new BlackBerry::Platform::String[numberOfInitialFiles], numberOfInitialFiles); for (unsigned i = 0; i < numberOfInitialFiles; ++i) initialFiles[i] = chooser->settings().selectedFiles[i]; SharedArray<BlackBerry::Platform::String> acceptMIMETypes; unsigned numberOfTypes = chooser->settings().acceptMIMETypes.size(); if (numberOfTypes > 0) acceptMIMETypes.reset(new BlackBerry::Platform::String[numberOfTypes], numberOfTypes); for (unsigned i = 0; i < numberOfTypes; ++i) acceptMIMETypes[i] = chooser->settings().acceptMIMETypes[i]; BlackBerry::Platform::String capture; #if ENABLE(MEDIA_CAPTURE) capture = chooser->settings().capture; #endif SharedArray<BlackBerry::Platform::String> chosenFiles; { PageGroupLoadDeferrer deferrer(m_webPagePrivate->m_page, true); TimerBase::fireTimersInNestedEventLoop(); if (!m_webPagePrivate->m_client->chooseFilenames(chooser->settings().allowsMultipleFiles, acceptMIMETypes, initialFiles, capture, chosenFiles)) return; } Vector<String> files(chosenFiles.length()); for (unsigned i = 0; i < chosenFiles.length(); ++i) files[i] = chosenFiles[i]; chooser->chooseFiles(files); }
size_t TestRunner::webHistoryItemCount() { SharedArray<BlackBerry::WebKit::WebPage::BackForwardEntry> backForwardList; BlackBerry::WebKit::DumpRenderTree::currentInstance()->page()->getBackForwardList(backForwardList); return backForwardList.length(); }
forceinline FloatValArgs::FloatValArgs(const SharedArray<FloatVal>& x) : PrimArgArray<FloatVal>(x.size()) { for (int i=x.size(); i--;) a[i] = x[i]; }
virtual const gnuradar::ResponseMessage Execute( gnuradar::ControlMessage& msg ){ gnuradar::ResponseMessage response_msg; try{ // reset any existing configuration producer_.reset(); consumer_.reset(); bufferManager_.reset(); hdf5_.reset(); array_.clear(); gnuradar::File* file = msg.mutable_file(); // standardizes units of input file. gr_helper::FormatFileFromMessage( file ); gnuradar::RadarParameters* rp = file->mutable_radarparameters(); // setup shared buffer header to assist in real-time processing header_ = SharedBufferHeaderPtr ( new ::yml::SharedBufferHeader ( constants::NUM_BUFFERS, rp->bytesperbuffer(), file->samplerate(), file->numchannels(), rp->prisperbuffer(), rp->samplesperbuffer() ) ); // setup gnuradar settings pointer GnuRadarSettingsPtr settings( new GnuRadarSettings() ); // read and parse configuration file-> GetSettings( settings, file ); // create a device to communicate with hardware GnuRadarDevicePtr gnuRadarDevice( new GnuRadarDevice( settings ) ); // make sure we don't have an existing data set if( gr_helper::HdfFileExists( file->basefilename() )) { throw std::runtime_error( "HDF5 File set " + fileName + " exists and cannot be overwritten. Change your " "base file set name and try again"); } // setup HDF5 attributes and file->set. hdf5_ = SetupHDF5( file ); // setup shared memory buffers CreateSharedBuffers( rp->bytesperbuffer() ); // setup the buffer manager bufferManager_ = SynchronizedBufferManagerPtr( new SynchronizedBufferManager( array_, constants::NUM_BUFFERS, rp->bytesperbuffer()) ); // setup table dimensions column = samples per ipp , row = IPP number std::vector<hsize_t> dims; dims.push_back(rp->prisperbuffer()); dims.push_back (static_cast<int> (rp->samplesperpri())); // setup producer thread producer_ = gnuradar::ProducerThreadPtr ( new ProducerThread ( bufferManager_, gnuRadarDevice ) ); // flush header information header_->Write(0,0,0); // setup consumer thread consumer_ = gnuradar::ConsumerThreadPtr( new ConsumerThread ( bufferManager_ , header_, hdf5_, dims ) ); // new model pcModel_->Initialize( bufferManager_, producer_, consumer_); // start producer thread pcModel_->Start(); response_msg.set_value(gnuradar::ResponseMessage::OK); response_msg.set_message("Data collection successfully started."); // Start status thread to broadcast status packets to any subscribers. if( statusServer_->IsActive() == false ) { statusServer_->Start(); } std::cout << "System is running..." << std::endl; } catch( std::runtime_error& e ){ response_msg.set_value(gnuradar::ResponseMessage::ERROR); response_msg.set_message(e.what()); } catch( H5::Exception& e ){ response_msg.set_value(gnuradar::ResponseMessage::ERROR); response_msg.set_message(e.getDetailMsg()); } return response_msg; }
forceinline IntArgs::IntArgs(const SharedArray<int>& x) : PrimArgArray<int>(x.size()) { for (int i=x.size(); i--;) a[i] = x[i]; }
void basicSample() { poco_assert( UDT_use_count == 0 ); // reality check // test shared_array with a built-in type char * cap = new char [ 100 ]; SharedArray<char> ca ( cap ); poco_assert( ca.get() == cap ); poco_assert( cap == ca.get() ); poco_assert( &ca[0] == cap ); strcpy( ca.get(), "Hot Dog with mustard and relish" ); poco_assert( strcmp( ca.get(), "Hot Dog with mustard and relish" ) == 0 ); poco_assert( strcmp( cap, "Hot Dog with mustard and relish" ) == 0 ); poco_assert( ca[0] == 'H' ); poco_assert( ca[30] == 'h' ); SharedArray<char> ca2 ( ca ); SharedArray<char> ca3 ( ca2 ); ca[0] = 'N'; ca[4] = 'd'; poco_assert( strcmp( ca.get(), "Not dog with mustard and relish" ) == 0 ); poco_assert( strcmp( ca2.get(), "Not dog with mustard and relish" ) == 0 ); poco_assert( strcmp( ca3.get(), "Not dog with mustard and relish" ) == 0 ); ca2.reset(); ca.reset(); poco_assert( ca.get() == 0 ); SharedArray<char> ca4; swap( ca3, ca4 ); poco_assert( strcmp( ca4.get(), "Not dog with mustard and relish" ) == 0 ); poco_assert( ca3.get() == 0 ); std::set< SharedArray<char> > sca; sca.insert(ca4); poco_assert( sca.find(ca4) != sca.end() ); poco_assert( sca.find(ca4) == sca.find( SharedArray<char>(ca4) ) ); // test shared_array with user defined type SharedArray<UDT> udta ( new UDT[3] ); udta[0].value( 111 ); udta[1].value( 222 ); udta[2].value( 333 ); SharedArray<UDT> udta2 ( udta ); poco_assert( udta[0].value() == 111 ); poco_assert( udta[1].value() == 222 ); poco_assert( udta[2].value() == 333 ); poco_assert( udta2[0].value() == 111 ); poco_assert( udta2[1].value() == 222 ); poco_assert( udta2[2].value() == 333 ); udta2.reset(); poco_assert( udta2.get() == 0 ); poco_assert( UDT_use_count == 3 ); // reality check std::cout << "OK\n"; }
virtual const std::string Execute( const xml::XmlPacketArgs& args ) { // reset any existing configuration producer_.reset(); consumer_.reset(); bufferManager_.reset(); hdf5_.reset(); array_.clear(); std::string response; std::string xml_data = command::ParseArg( "file", args ); // incoming "file" is self-contained xml data. bool data_is_xml = true; xml_data = xml::XmlPacket::DecodeXml( xml_data ); // parse configuration file ConfigFile configFile( xml_data, data_is_xml ); // create constants const int BUFFER_SIZE = configFile.BytesPerSecond(); const double SAMPLE_RATE = configFile.SampleRate(); const int NUM_CHANNELS = configFile.NumChannels(); const int IPPS_PER_BUFFER = static_cast<int>( ceil(1.0/configFile.IPP())); const int SAMPLES_PER_BUFFER = static_cast<int> ( configFile.SamplesPerIpp() * configFile.NumChannels() ); // setup shared buffer header to assist in real-time processing header_ = SharedBufferHeaderPtr( new ::xml::SharedBufferHeader( constants::NUM_BUFFERS, BUFFER_SIZE, SAMPLE_RATE, NUM_CHANNELS, IPPS_PER_BUFFER, SAMPLES_PER_BUFFER )); // create a response packet and return to requester std::string destination = command::ParseArg( "source", args ); xml::XmlPacketArgs responsePacket; responsePacket["destination"] = destination; responsePacket["type"] = "response"; gnuradar::xml::XmlPacket packet("gnuradar_server"); try{ // make sure we don't have an existing data set CheckForExistingFileSet ( configFile.DataFileBaseName() ) ; // setup HDF5 attributes and file set. hdf5_ = SetupHDF5( configFile ); // read and parse configuration file. GnuRadarSettingsPtr settings = GetSettings( configFile ); // create a device to communicate with hardware GnuRadarDevicePtr gnuRadarDevice( new GnuRadarDevice( settings ) ); // setup shared memory buffers CreateSharedBuffers( BUFFER_SIZE ); // setup the buffer manager bufferManager_ = SynchronizedBufferManagerPtr( new SynchronizedBufferManager( array_, constants::NUM_BUFFERS, BUFFER_SIZE) ); // setup table dimensions column = samples per ipp , row = IPP number vector<hsize_t> dims; dims.push_back( IPPS_PER_BUFFER ); dims.push_back ( static_cast<int> ( configFile.SamplesPerIpp() * configFile.NumChannels() ) ); // setup producer thread producer_ = gnuradar::ProducerThreadPtr ( new ProducerThread ( bufferManager_, gnuRadarDevice ) ); // flush header information header_->Close(); // setup consumer thread consumer_ = gnuradar::ConsumerThreadPtr( new ConsumerThread ( bufferManager_ , header_, hdf5_, dims ) ); // new model pcModel_->Initialize( bufferManager_, producer_, consumer_); // start producer thread pcModel_->Start(); responsePacket["value"] = "OK"; responsePacket["message"] = "Data collection successfully started."; response = packet.Format( responsePacket ); // Start status thread to broadcast status packets to any subscribers. statusThread_->Stop(); statusThread_->Start(); } catch( std::runtime_error& e ){ responsePacket["value"] = "ERROR"; responsePacket["message"] = e.what(); response = packet.Format( responsePacket ); } catch( H5::Exception& e ){ responsePacket["value"] = "ERROR"; responsePacket["message"] = e.getDetailMsg(); response = packet.Format( responsePacket ); } return response; }