inline void ObservableSettings::enableUpdates() {
updatesEnabled_ = true;
updatesDeferred_ = false;
// if there are outstanding deferred updates, do the notification
if (deferredObservers_.size() > 0)
{
bool successful = true;
std::string errMsg;
QL_TRACE("deferred notification of " << deferredObservers_.size() << " observers");
for (iterator i=deferredObservers_.begin(); i!=deferredObservers_.end(); ++i) {
try {
(*i)->update();
} catch (std::exception& e) {
successful = false;
errMsg = e.what();
} catch (...) {
successful = false;
}
}
deferredObservers_.clear();
QL_ENSURE(successful,
"could not notify one or more observers: " << errMsg);
}
}
void sanity_checks() {
ASSERT_TRUE(cm.begin() == cm.end());
for (size_t i = 0;i < NINS; ++i) {
um.insert(17 * i);
}
graphlab::thread_group thrgroup;
for (size_t i = 0; i < 10; ++i) {
thrgroup.launch(boost::bind(parallel_inserter,
i * NINS/10,
(i + 1) * NINS / 10));
}
thrgroup.join();
std::cout << "Size: " << cm.size() << std::endl;
std::cout << "Capacity: " << cm.capacity() << std::endl;
std::cout << "Load Factor: " << cm.load_factor() << std::endl;
for (size_t i = 0;i < NINS; ++i) {
if (cm.get_sync(17 * i).first == false) {
std::cout << cm.count(17 * i) << "\n";
std::cout << "Failure on: " << 17 * i << std::endl;
assert(cm.get_sync(17 * i).first == true);
}
assert(um.count(17 * i) == 1);
}
assert(cm.size() == NINS);
assert(um.size() == NINS);
for (size_t i = 0;i < NINS; i+=2) {
um.erase(17*i);
}
for (size_t i = 0; i < 10; ++i) {
thrgroup.launch(boost::bind(parallel_erase,
i * NINS/10,
(i + 1) * NINS / 10));
}
thrgroup.join();
for (size_t i = 0;i < NINS; i+=2) {
assert(cm.get_sync(17*i).first == (bool)(i % 2));
assert(um.count(17*i) == i % 2);
}
assert(cm.size() == NINS / 2);
assert(um.size() == NINS / 2);
}
inline void ObservableSettings::registerDeferredObservers(boost::unordered_set<Observer*>& observers) {
if (updatesDeferred())
{
QL_TRACE("adding " << observers.size() << " observers to the deferred list");
deferredObservers_.insert(observers.begin(), observers.end());
}
}
//calculates average of vectors
boost::unordered_map<string, double> Cluster::_centroid(boost::unordered_set<int>& cluster_list) {
unordered_string_map centroid;
int cluster_size = cluster_list.size();
for (boost::unordered_set<int>::iterator it = cluster_list.begin(); it != cluster_list.end(); ++it) {
//add each element of vector to centroid
for (unordered_string_map::iterator ivec = doc_term_index[ *it ].begin(); ivec != doc_term_index[ *it ].end(); ++ivec) {
//element (term) doesn't exist, we add it to the map
if ( centroid.count ( ivec->first ) == 0) {
//cout << "ivec second: " << ivec->second <<endl;
//cout << "cluster_size: " << cluster_size <<endl;
centroid.insert(unordered_string_map::value_type( ivec->first, double( (double)ivec->second / cluster_size ) ));
}
else {
centroid[ivec->first] += double( ((double)ivec->second / cluster_size) );
}
}
}
return centroid;
}
static void serialize(storage_type& s, const boost::unordered_set<T>& o)
{
uint32_t sz = o.size();
s.serialize(sz);
for (auto it = o.begin(), it_end = o.end(); it != it_end; ++it)
s.serialize(*it);
}
void print(const std::string& outputFile, const boost::unordered_set<ZCTA>& zctas, const AdjacencySet& adjacencies) {
std::ofstream out(outputFile.c_str());
out << zctas.size() << std::endl;
for (boost::unordered_set<ZCTA>::const_iterator i = zctas.cbegin(); i != zctas.cend(); ++i)
out << i->id() << " " << i->interiorPoint().x().get_num() << " "
<< i->interiorPoint().y().get_num() << std::endl;
out << adjacencies.size() << std::endl;
for (AdjacencySet::iterator i = adjacencies.begin(), end = adjacencies.end(); i != end; ++i)
out << i->first.id() << " " << i->second.id() << std::endl;
}
inline void Observable::notifyObservers() {
// check whether the notifications should be triggered
if (!settings_.updatesEnabled())
{
// if updates are only deferred, flag this for later notification
// these are held centrally by the settings singleton
if (settings_.updatesDeferred())
settings_.registerDeferredObservers(observers_);
return;
}
if (observers_.size() > 0)
{
bool successful = true;
std::string errMsg;
QL_TRACE("direct notification of " << observers_.size() << " observers");
for (iterator i=observers_.begin(); i!=observers_.end(); ++i) {
try {
(*i)->update();
} catch (std::exception& e) {
// quite a dilemma. If we don't catch the exception,
// other observers will not receive the notification
// and might be left in an incorrect state. If we do
// catch it and continue the loop (as we do here) we
// lose the exception. The least evil might be to try
// and notify all observers, while raising an
// exception if something bad happened.
successful = false;
errMsg = e.what();
} catch (...) {
successful = false;
}
}
QL_ENSURE(successful,
"could not notify one or more observers: " << errMsg);
}
}
void save(Archive & ar, const boost::unordered_set<T> & t, unsigned int version)
{
// write the size
// TODO: should we handle bucket size as well?
typedef typename boost::unordered_set<T>::size_type size_type;
typedef typename boost::unordered_set<T>::const_iterator const_iterator;
size_type size = t.size();
ar & BOOST_SERIALIZATION_NVP(size);
unsigned int count = 0;
for (const_iterator it = t.begin(); it != t.end(); it++) {
ar & boost::serialization::make_nvp("item" + count, *it);
count++;
}
}
static void exec(OutArcType& oarc, const boost::unordered_set<T>& vec){
serialize_iterator(oarc,
vec.begin(), vec.end(), vec.size());
}
int get_count() const { return seen_.size(); }
