void
ReceiveListenerSet::data_received(const ReceivedDataSample& sample,
const RepoIdSet& incl_excl,
ConstrainReceiveSet constrain)
{
DBG_ENTRY_LVL("ReceiveListenerSet", "data_received", 6);
OPENDDS_VECTOR(RcHandle<TransportReceiveListener>) handles;
{
GuardType guard(this->lock_);
for (MapType::iterator itr = map_.begin(); itr != map_.end(); ++itr) {
if (constrain == ReceiveListenerSet::SET_EXCLUDED) {
if (itr->second && incl_excl.count(itr->first) == 0) {
handles.push_back(itr->second);
}
} else if (constrain == ReceiveListenerSet::SET_INCLUDED) { //SET_INCLUDED
if (itr->second && incl_excl.count(itr->first) != 0) {
handles.push_back(itr->second);
}
} else {
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: ReceiveListenerSet::data_received - NOTHING\n"));
}
}
}
for (size_t i = 0; i < handles.size(); ++i) {
if (i < handles.size() - 1 && sample.sample_) {
// demarshal (in data_received()) updates the rd_ptr() of any of
// the message blocks in the chain, so give it a duplicated chain.
ReceivedDataSample rds(sample);
handles[i]->data_received(rds);
} else {
handles[i]->data_received(sample);
}
}
}
// recursively delete a dir
const bool rds(const char* p) {
path top(p);
if (top.isndir()) return false;
list<str> files=top.files();
uint l=files.size();
for_n(i, l) if (!rm((top / files[i]).tocstr())) return false;
list<str> dirs=top.dirs();
l=dirs.size();
for_n(i, l) if (!rds((top / dirs[i]).tocstr())) return false;
return rd(p);
}
/**
* Implementation that updates result with the matching parts in source
* Relies on the fact that getMember returns a C++ reference to each part of \a result, which is then updated
* with a property found in source.
*/
virtual bool composeTypeImpl(const PropertyBag& source, typename internal::AssignableDataSource<T>::reference_t result) const {
// The default implementation decomposes result and refreshes it with source.
TypeInfoRepository::shared_ptr tir = Types();
internal::ReferenceDataSource<T> rds(result);
rds.ref(); // prevent dealloc.
PropertyBag decomp;
// only try refreshProperties if decomp's type is equal to source type.
// update vs refresh: since it is intentional that the decomposition leads to references to parts of result,
// only refreshProperties() is meaningful (ie we have a one-to-one mapping). In case of sequences, this would
// of course not match, so this is struct specific.
return typeDecomposition( &rds, decomp, false) && ( tir->type(decomp.getType()) == tir->type(source.getType()) ) && refreshProperties(decomp, source);
}
int main(int argc, char *argv[]){
struct stat buf;
void *start;
char *point;
char *point1;
if (argc != 3) {
fprintf(stderr, "Error input \n");
exit(EXIT_FAILURE);
}
int imgfile = open(argv[1], O_RDONLY);
char *filename=argv[2];
if (imgfile < 0){
fprintf(stderr, "Error no such file \n");
exit(EXIT_FAILURE);
}
fstat(imgfile, &buf);
start = mmap(NULL, buf.st_size, PROT_READ, MAP_PRIVATE, imgfile, 0);
if(start == MAP_FAILED)
return;
point=start;
point1=start;
block_size=blocksize(point);
int rd_s=rds(point);
int rd_b=rdb(point);
int n=0;
ss=block_size*rd_s;
point=point+block_size*rd_s;
while(point[0]!=0x00){
readfile(point);
n++;
point=point+64;
}
// printf("%d",n);
getfile(point1,filename,n);
//info end
munmap(start, buf.st_size);
close(imgfile);
return 0;
}
TEST(mock_MeterS0, basic_non_blocking_read)
{
mock_S0hwif *hwif = new mock_S0hwif();
std::list<Option> opt;
opt.push_back(Option("send_zero", true));
EXPECT_CALL(*hwif, _open()).Times(1).WillRepeatedly(Return(true));
EXPECT_CALL(*hwif, _close()).Times(1).WillOnce(Return(true));
EXPECT_CALL(*hwif, is_blocking()).Times(2).WillRepeatedly(Return(false));
EXPECT_CALL(*hwif, status()).Times(AtLeast(1)).WillRepeatedly(Return(0));
MeterS0 m(opt, hwif);
ASSERT_EQ(SUCCESS, m.open());
std::vector<Reading> rds(4);
ASSERT_EQ(m.read(rds, 4), 4);
m.close(); // this might be called and should not cause problems
}
path& path::m_normalize()
{
if (m_pathname.empty()) return *this;
path temp;
iterator start(begin());
iterator last(end());
iterator stop(last--);
for (iterator itr(start); itr != stop; ++itr)
{
// ignore "." except at start and last
if (itr->native().size() == 1
&& (itr->native())[0] == dot
&& itr != start
&& itr != last) continue;
// ignore a name and following ".."
if (!temp.empty()
&& itr->native().size() == 2
&& (itr->native())[0] == dot
&& (itr->native())[1] == dot) // dot dot
{
string_type lf(temp.filename().native());
if (lf.size() > 0
&& (lf.size() != 1
|| (lf[0] != dot
&& lf[0] != separator))
&& (lf.size() != 2
|| (lf[0] != dot
&& lf[1] != dot
# ifdef BOOST_WINDOWS_API
&& lf[1] != colon
# endif
)
)
)
{
temp.remove_filename();
// if not root directory, must also remove "/" if any
if (temp.m_pathname.size() > 0
&& temp.m_pathname[temp.m_pathname.size()-1]
== separator)
{
string_type::size_type rds(
root_directory_start(temp.m_pathname, temp.m_pathname.size()));
if (rds == string_type::npos
|| rds != temp.m_pathname.size()-1)
{ temp.m_pathname.erase(temp.m_pathname.size()-1); }
}
iterator next(itr);
if (temp.empty() && ++next != stop
&& next == last && *last == dot_path) temp /= dot_path;
continue;
}
}
temp /= *itr;
};
if (temp.empty()) temp /= dot_path;
m_pathname = temp.m_pathname;
return *this;
}
int main(int argc, char **argv)
{
int c, option_index;
if (argc < 2)
print_help(argv[0], -1);
while (1) {
option_index = 0;
c = getopt_long(argc, argv,
#if PCIMAXFM_ENABLE_TX_TOGGLE
"t::"
#endif /* PCIMAXFM_ENABLE_TX_TOGGLE */
"f::p::s::"
#if PCIMAXFM_ENABLE_RDS
#if PCIMAXFM_ENABLE_RDS_TOGGLE
"g::"
#endif /* PCIMAXFM_ENABLE_RDS_TOGGLE */
"r:"
#endif /* PCIMAXFM_ENABLE_RDS */
"d::vqehH",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
#if PCIMAXFM_ENABLE_TX_TOGGLE
case 't':
tx(optarg);
break;
#endif /* PCIMAXFM_ENABLE_TX_TOGGLE */
case 'f':
freq(optarg);
break;
case 'p':
power(optarg);
break;
case 's':
stereo(optarg);
break;
#if PCIMAXFM_ENABLE_RDS
#if PCIMAXFM_ENABLE_RDS_TOGGLE
case 'g':
rds_signal(optarg);
break;
#endif /* PCIMAXFM_ENABLE_RDS_TOGGLE */
case 'r':
rds(optarg);
break;
#endif /* PCIMAXFM_ENABLE_RDS */
case 'd':
device(optarg);
break;
case 'v':
verbosity = 1;
DEBUG_MSG("Verbose output.");
break;
case 'q':
verbosity = -1;
break;
case 'e':
print_version(argv[0]);
case 'h':
print_help(argv[0], 0);
#if PCIMAXFM_ENABLE_RDS
case 'H':
print_help_rds(0);
#endif /* PCIMAXFM_ENABLE_RDS */
default:
exit(1);
}
}
dev_close();
return 0;
}
nsresult
nsSafariProfileMigrator::SetDownloadHandlers(void* aTransform, nsIPrefBranch* aBranch)
{
PrefTransform* xform = (PrefTransform*)aTransform;
if (!xform->boolValue) {
// If we're not set to auto-open safe downloads, we need to clear out the
// mime types list which contains default handlers.
nsCOMPtr<nsIProperties> fileLocator(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
nsCOMPtr<nsILocalFile> mimeRegistryFile;
fileLocator->Get(NS_APP_USER_MIMETYPES_50_FILE, NS_GET_IID(nsILocalFile),
getter_AddRefs(mimeRegistryFile));
nsCOMPtr<nsIIOService> ioService(do_GetService("@mozilla.org/network/io-service;1"));
nsCOMPtr<nsIProtocolHandler> ph;
ioService->GetProtocolHandler("file", getter_AddRefs(ph));
nsCOMPtr<nsIFileProtocolHandler> fph(do_QueryInterface(ph));
nsCOMPtr<nsIRDFService> rdfService(do_GetService("@mozilla.org/rdf/rdf-service;1"));
nsCOMPtr<nsIRDFDataSource> mimeTypes;
nsCAutoString dsURL;
fph->GetURLSpecFromFile(mimeRegistryFile, dsURL);
rdfService->GetDataSourceBlocking(dsURL.get(), getter_AddRefs(mimeTypes));
nsCOMPtr<nsIRDFResource> overridesListResource;
rdfService->GetResource(NS_LITERAL_CSTRING("urn:mimetypes:root"),
getter_AddRefs(overridesListResource));
nsCOMPtr<nsIRDFContainer> overridesList(do_CreateInstance("@mozilla.org/rdf/container;1"));
overridesList->Init(mimeTypes, overridesListResource);
nsCOMPtr<nsIRDFResource> handlerPropArc, externalApplicationArc;
rdfService->GetResource(NC_URI(handlerProp), getter_AddRefs(handlerPropArc));
rdfService->GetResource(NC_URI(externalApplication),
getter_AddRefs(externalApplicationArc));
PRInt32 count;
overridesList->GetCount(&count);
for (PRInt32 i = count; i >= 1; --i) {
nsCOMPtr<nsIRDFNode> currOverrideNode;
overridesList->RemoveElementAt(i, false, getter_AddRefs(currOverrideNode));
nsCOMPtr<nsIRDFResource> currOverride(do_QueryInterface(currOverrideNode));
nsCOMPtr<nsIRDFNode> handlerPropNode;
mimeTypes->GetTarget(currOverride, handlerPropArc, true,
getter_AddRefs(handlerPropNode));
nsCOMPtr<nsIRDFResource> handlerPropResource(do_QueryInterface(handlerPropNode));
if (handlerPropResource) {
nsCOMPtr<nsIRDFNode> externalApplicationNode;
mimeTypes->GetTarget(handlerPropResource, externalApplicationArc,
true, getter_AddRefs(externalApplicationNode));
nsCOMPtr<nsIRDFResource> externalApplicationResource(do_QueryInterface(externalApplicationNode));
// Strip the resources down so that the datasource is completely flushed.
if (externalApplicationResource)
CleanResource(mimeTypes, externalApplicationResource);
CleanResource(mimeTypes, handlerPropResource);
}
CleanResource(mimeTypes, currOverride);
}
nsCOMPtr<nsIRDFRemoteDataSource> rds(do_QueryInterface(mimeTypes));
if (rds)
rds->Flush();
}
return NS_OK;
}
