void exercise(BinInputStream& stream) { static float percents[] = { 1.0, 0.5, 0.25, 0.1, 0.15, 0.113, 0.333, 0.0015, 0.0013 }; int numPercents = sizeof(percents) / sizeof(float); const unsigned int bufferMax = 4096; XMLByte buffer[bufferMax]; int iteration = 0; unsigned int bytesRead = 0; do { // Calculate a percentage of our maximum buffer size, going through // them round-robin float percent = percents[iteration % numPercents]; unsigned int bufCnt = (unsigned int)(bufferMax * percent); // Check to make sure we didn't go out of bounds if (bufCnt <= 0) bufCnt = 1; if (bufCnt > bufferMax) bufCnt = bufferMax; // Read bytes into our buffer bytesRead = stream.readBytes(buffer, bufCnt); //XERCES_STD_QUALIFIER cerr << "Read " << bytesRead << " bytes into a " << bufCnt << " byte buffer\n"; if (bytesRead > 0) { // Write the data to standard out XERCES_STD_QUALIFIER cout.write((char*)buffer, bytesRead); } ++iteration; } while (bytesRead > 0); }
Components::Cookie* AssemblyFactoryImpl::create_assembly (const char* assembly_loc) throw (Components::Deployment::InvalidLocation, Components::CreateFailure) { DEBUG_OUT2( "AssemblyFactoryImpl: creating new assembly for ", assembly_loc ); // // exclusive // QedoLock lock(&mutex_); // // get path // XMLURL uri(assembly_loc); const XMLCh* p = uri.getPath(); if(!p) { NORMAL_ERR2( "AssemblyFactoryImpl: invalid assembly location: ", assembly_loc ); throw Components::Deployment::InvalidLocation(); } std::string name = Qedo::transcode(p); std::string::size_type pos = name.find_last_of("/"); if (pos != std::string::npos) { name.erase(0, pos + 1); } // // make input stream // URLInputSource inputSource(uri); BinInputStream* inputStream; try { inputStream = inputSource.makeStream(); } catch(...) { NORMAL_ERR2( "AssemblyFactoryImpl: invalid assembly location: ", assembly_loc ); throw Components::Deployment::InvalidLocation(); } if (!inputStream) { NORMAL_ERR2( "AssemblyFactoryImpl: invalid assembly location", assembly_loc ); throw Components::Deployment::InvalidLocation(); } // // create new cookie // Cookie_impl* new_cookie = new Cookie_impl(); const char * s = new_cookie->to_string(); std::string uuid = s; CORBA::string_free(const_cast<char*>(s)); // // store the package // std::string dir = getPath( packageDirectory_ ) + uuid; if( makeDir(dir) ) { NORMAL_ERR3( "AssemblyFactoryImpl: directory ", dir, " can not be created"); throw Components::CreateFailure(); } std::string package_name = getPath( dir ) + name; std::ofstream packageFile(package_name.c_str(), std::ios::binary|std::ios::app); if ( ! packageFile) { NORMAL_ERR2( "AssemblyFactoryImpl: cannot open file ", package_name ); throw Components::CreateFailure(); } unsigned char* buf = new unsigned char[4096]; unsigned int len = inputStream->readBytes(buf, 4096); while (len) { packageFile.write((const char*)buf, len); len = inputStream->readBytes(buf, 4096); } delete [] buf; packageFile.close(); delete inputStream; // // create new assembly // AssemblyImpl* ass = new AssemblyImpl(package_name, new_cookie, nameService_); assemblies_.push_back(ass); DEBUG_OUT( "..... done" ); return new_cookie; }
Sequence FunctionUnparsedText::createSequence(DynamicContext* context, int flags) const { Item::Ptr uriArg = getParamNumber(1, context)->next(context); if(uriArg.isNull()) { return Sequence(context->getMemoryManager()); } const XMLCh *uri = uriArg->asString(context); if(!XPath2Utils::isValidURI(uri, context->getMemoryManager())) XQThrow(FunctionException, X("FunctionUnparsedText::createSequence"), X("The argument to fn:unparsed-text() is not a valid URI [err:XTDE1170]")); // TBD Implement a URIResolver method for resolving unparsed text - jpcs const XMLCh *baseUri = context->getBaseURI(); InputSource *srcToUse = 0; if(context->getXMLEntityResolver()){ XMLResourceIdentifier resourceIdentifier(XMLResourceIdentifier::UnKnown, uri, 0, XMLUni::fgZeroLenString, baseUri); srcToUse = context->getXMLEntityResolver()->resolveEntity(&resourceIdentifier); } if(srcToUse == 0) { try { // Resolve the uri against the base uri XMLURL urlTmp; if(baseUri && *baseUri) { urlTmp.setURL(baseUri, uri); } else { urlTmp.setURL(uri); } srcToUse = new URLInputSource(urlTmp); } catch(const MalformedURLException &e) { } } if(srcToUse == 0) { // It's not a URL, so let's assume it's a local file name. if(baseUri && *baseUri) { AutoDeallocate<XMLCh> tmpBuf(XMLPlatformUtils::weavePaths(baseUri, uri), XMLPlatformUtils::fgMemoryManager); srcToUse = new LocalFileInputSource(tmpBuf); } else { srcToUse = new LocalFileInputSource(uri); } } Janitor<InputSource> janIS(srcToUse); if(getNumArgs() == 2) { const XMLCh *encoding = getParamNumber(2, context)->next(context)->asString(context); srcToUse->setEncoding(encoding); } XMLBuffer result; try { BinInputStream *stream = srcToUse->makeStream(); if(stream == NULL) { XMLBuffer buf; buf.set(X("Cannot read unparsed content from ")); buf.append(uri); buf.append(X(" [err:XTDE1170]")); XQThrow2(FunctionException,X("FunctionUnparsedText::createSequence"), buf.getRawBuffer()); } Janitor<BinInputStream> janStream(stream); #ifdef HAVE_GETCONTENTTYPE if(FunctionMatches::matches(stream->getContentType(), X("(text|application)/(xml|[^ +;]+\\+xml)"), X("i"))) { srcToUse->setEncoding(0); srcToUse->setEncoding(FindXMLEncoding().start(*srcToUse, context)); } #endif XPath2Utils::readSource(stream, context->getMemoryManager(), result, srcToUse->getEncoding()); } catch(XMLException &e) { XMLBuffer buf; buf.set(X("Exception reading unparsed content: ")); buf.append(e.getMessage()); buf.append(X(" [err:XTDE1190]")); XQThrow2(FunctionException,X("FunctionUnparsedText::createSequence"), buf.getRawBuffer()); } return Sequence(context->getItemFactory()->createString(result.getRawBuffer(), context), context->getMemoryManager()); }