bool WRLDRecord::deep_equals(Record *master, RecordOp &read_self, RecordOp &read_master, boost::unordered_set<Record *> &identical_records)
{
//Precondition: equals has been run for these records and returned true
// all child records have been visited
const WRLDRecord *master_wrld = (WRLDRecord *)master;
if(CELLS.size() > master_wrld->CELLS.size())
return false;
if(CELL != NULL)
{
if(master_wrld->CELL != NULL)
{
if(identical_records.count(CELL) == 0)
return false;
}
else
return false;
}
for(uint32_t ListIndex = 0; ListIndex < CELLS.size(); ++ListIndex)
if(identical_records.count(CELLS[ListIndex]) == 0)
return false;
return true;
}
void VNode::collect_vnodes(boost::unordered_set<Node*>& nodes,uint& total)
{
total++;
boost::unordered_set<Node*>::iterator it = nodes.find(this);
if(it==nodes.end())
nodes.insert(this);
}
PNS_NODE::~PNS_NODE()
{
TRACE( 0, "PNS_NODE::delete %p", this );
if( !m_children.empty() )
{
TRACEn( 0, "attempting to free a node that has kids.\n" );
assert( false );
}
#ifdef DEBUG
if( allocNodes.find( this ) == allocNodes.end() )
{
TRACEn( 0, "attempting to free an already-free'd node.\n" );
assert( false );
}
allocNodes.erase( this );
#endif
for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i )
{
if( (*i)->BelongsTo( this ) )
delete *i;
}
releaseGarbage();
unlinkParent();
delete m_index;
}
static void updateHelper (SLE::ref entry,
boost::unordered_set< uint256 >& seen,
boost::unordered_map< currencyIssuer_t, std::vector<OrderBook::pointer> >& destMap,
boost::unordered_map< currencyIssuer_t, std::vector<OrderBook::pointer> >& sourceMap,
boost::unordered_set< currencyIssuer_t >& XRPBooks,
int& books)
{
if ((entry->getType () == ltDIR_NODE) && (entry->isFieldPresent (sfExchangeRate)) &&
(entry->getFieldH256 (sfRootIndex) == entry->getIndex()))
{
const uint160& ci = entry->getFieldH160 (sfTakerPaysCurrency);
const uint160& co = entry->getFieldH160 (sfTakerGetsCurrency);
const uint160& ii = entry->getFieldH160 (sfTakerPaysIssuer);
const uint160& io = entry->getFieldH160 (sfTakerGetsIssuer);
uint256 index = Ledger::getBookBase (ci, ii, co, io);
if (seen.insert (index).second)
{
// VFALCO TODO Reduce the clunkiness of these parameter wrappers
OrderBook::pointer book = boost::make_shared<OrderBook> (boost::cref (index),
boost::cref (ci), boost::cref (co), boost::cref (ii), boost::cref (io));
sourceMap[currencyIssuer_ct (ci, ii)].push_back (book);
destMap[currencyIssuer_ct (co, io)].push_back (book);
if (co.isZero())
XRPBooks.insert(currencyIssuer_ct (ci, ii));
++books;
}
}
}
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;
}
float KernelKmeansClusterer::distanceToCluster(int sampleId,
const boost::unordered_set<int>& clusterIdSet) {
if (clusterIdSet.empty()) {
return FLT_MAX;
}
// the sum of weight of the cluster
float weightSum = 0.0f;
// the sum of kernels from the sample to all samples in the cluster, multiplied by the weight
float kernelSum = 0.0f;
// the sum of kernels from each pair of samples in the cluster, multiplied by weights
float kernelPairSum = 0.0f;
for (boost::unordered_set<int>::const_iterator iter = clusterIdSet.begin();
iter != clusterIdSet.end(); ++iter) {
float weight = mWeightArray[*iter];
weightSum += weight;
float kernelResult = (*mpKernel)(sampleId, *iter);
kernelSum += weight * kernelResult;
for (boost::unordered_set<int>::const_iterator _iter =
clusterIdSet.begin(); _iter != clusterIdSet.end(); ++_iter) {
float _kernelResult = (*mpKernel)(*iter, *_iter);
kernelPairSum += weight * mWeightArray[*_iter] * _kernelResult;
}
}
float kernelSelf = (*mpKernel)(sampleId, sampleId);
if (weightSum == 0.0f) {
return FLT_MAX;
}
return kernelSelf - 2 * kernelSum / weightSum
+ kernelPairSum / (weightSum * weightSum);
}
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 cluster_machine::dfs(const size_t curr, boost::unordered_set<size_t> &vis)
{
vis.insert(curr);
for (size_t e = first_[curr]; e != -1; e = next_[e]) {
if ( vis.find(v_[e]) == vis.end() )
dfs(v_[e], vis);
}
}
Strings get_live_object_names() {
IMP::Vector<std::string> ret;
for (boost::unordered_set<Object*>::const_iterator it = live_.begin();
it != live_.end(); ++it) {
ret.push_back((*it)->get_name());
}
return ret;
}
inline std::pair<boost::unordered_set<boost::shared_ptr<Observable> >::iterator, bool>
Observer::registerWith(const boost::shared_ptr<Observable>& h) {
if (h) {
h->registerObserver(this);
return observables_.insert(h);
}
return std::make_pair(observables_.end(), false);
}
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 MixMaterial::AddReferencedMaterials(boost::unordered_set<const Material *> &referencedMats) const {
Material::AddReferencedMaterials(referencedMats);
referencedMats.insert(matA);
matA->AddReferencedMaterials(referencedMats);
referencedMats.insert(matB);
matB->AddReferencedMaterials(referencedMats);
}
inline Observer& Observer::operator=(const Observer& o) {
iterator i;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_ = o.observables_;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
return *this;
}
IMPKERNEL_END_NAMESPACE
IMPKERNEL_BEGIN_INTERNAL_NAMESPACE
void check_live_objects() {
for (boost::unordered_set<Object*>::const_iterator it = live_.begin();
it != live_.end(); ++it) {
IMP_USAGE_CHECK((*it)->get_ref_count() > 0,
"Object " << (*it)->get_name() << " is not ref counted.");
}
}
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;
}
void update(const key_type& inKey, const boost::unordered_set<value_type>& inValues)
{
{
boost::unordered_set<value_type> curValues(getValues(inKey));
for (auto it = curValues.begin(); it != curValues.end(); ++it)
if (inValues.find(*it) == inValues.end())
drop(inKey, *it);
}
insert(inKey, inValues);
}
void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
{
// Check for a 'file' parameter
CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
// If there is a file specified, open and execute it
if (!file.empty())
{
Paths.insert(file);
try
{
m_ScriptInterface->LoadGlobalScriptFile(file);
}
catch (PSERROR_Scripting& e)
{
LOGERROR("GUI: Error executing script %s: %s", utf8_from_wstring(file), e.what());
}
}
// If it has a directory attribute, read all JS files in that directory
CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
if (!directory.empty())
{
VfsPaths pathnames;
vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
for (const VfsPath& path : pathnames)
{
// Only load new files (so when the insert succeeds)
if (Paths.insert(path).second)
try
{
m_ScriptInterface->LoadGlobalScriptFile(path);
}
catch (PSERROR_Scripting& e)
{
LOGERROR("GUI: Error executing script %s: %s", path.string8(), e.what());
}
}
}
// Execute inline scripts
try
{
CStr code(Element.GetText());
if (!code.empty())
m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
}
catch (PSERROR_Scripting& e)
{
LOGERROR("GUI: Error executing inline script: %s", e.what());
}
}
IMPKERNEL_END_NAMESPACE
IMPKERNEL_BEGIN_INTERNAL_NAMESPACE
void check_live_objects() {
for (boost::unordered_set<Object*>::const_iterator it = live_.begin();
it != live_.end(); ++it) {
IMP_USAGE_CHECK((*it)->get_ref_count() > 0,
"Object " << (*it)->get_name()
<< " is alive but not ref counted - memory leakage possible."
<< " This usually happens if an owning pointer is released"
<< " without being either deleted manually or assigned to"
<< " another owning pointer.");
}
}
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++;
}
}
TKmerMapSimple
kmerify_graph_simple(String<TVertexDescriptor const> const & order,
TGraph const & graph,
std::vector<VertexLabels> & vertex_vector,
boost::unordered_set<TVertexDescriptor> const & free_nodes,
boost::unordered_map< std::pair<TVertexDescriptor, TVertexDescriptor>, boost::dynamic_bitset<> > & edge_ids,
int const & kmer_size
)
{
TKmerMapSimple kmer_map;
for (Iterator<String<TVertexDescriptor const> const>::Type it = begin(order) ; it != end(order) ; ++it)
{
TVertexDescriptor const & source_vertex = *it;
if (free_nodes.count(source_vertex) == 0)
{
boost::dynamic_bitset<> id_bits(edge_ids.begin()->second.size());
id_bits.flip();
check_kmers_simple(vertex_vector[source_vertex].dna, graph, source_vertex, vertex_vector, free_nodes, edge_ids, id_bits, kmer_map, static_cast<std::size_t>(kmer_size));
}
}
return kmer_map;
}
void load(Archive & ar, boost::unordered_set<T> & t, unsigned int version)
{
// clear the set
t.clear();
// read the size
typedef typename boost::unordered_set<T>::size_type size_type;
size_type size;
ar & BOOST_SERIALIZATION_NVP(size);
for (size_type i = 0; i < size; i++) {
// read a pair
T item;
ar & boost::serialization::make_nvp("item"+i, item);
// insert it into the set
t.insert(item);
}
}
/**
* @callgraph
*/
void CGUI::LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths)
{
Paths.insert(Filename);
CXeromyces XeroFile;
if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
return;
XMBElement node = XeroFile.GetRoot();
CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
try
{
if (root_name == "objects")
{
Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
// Re-cache all values so these gets cached too.
//UpdateResolution();
}
else if (root_name == "sprites")
Xeromyces_ReadRootSprites(node, &XeroFile);
else if (root_name == "styles")
Xeromyces_ReadRootStyles(node, &XeroFile);
else if (root_name == "setup")
Xeromyces_ReadRootSetup(node, &XeroFile);
else
debug_warn(L"CGUI::LoadXmlFile error");
}
catch (PSERROR_GUI& e)
{
LOGERROR("Errors loading GUI file %s (%u)", Filename.string8(), e.getCode());
return;
}
}
void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
{
// Check for a 'file' parameter
CStrW file (Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("file") ).FromUTF8());
// If there is a file specified, open and execute it
if (! file.empty())
{
Paths.insert(file);
try
{
m_ScriptInterface->LoadGlobalScriptFile(file);
}
catch (PSERROR_Scripting& e)
{
LOGERROR(L"GUI: Error executing script %ls: %hs", file.c_str(), e.what());
}
}
// Execute inline scripts
try
{
CStr code (Element.GetText());
if (! code.empty())
m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
}
catch (PSERROR_Scripting& e)
{
LOGERROR(L"GUI: Error executing inline script: %hs", e.what());
}
}
TKmerMap
kmerifyGraph(String<TVertexDescriptor const> const & order,
TGraph const & graph,
std::vector<VertexLabels> & vertex_vector,
boost::unordered_set<TVertexDescriptor> const & free_nodes,
boost::unordered_map< std::pair<TVertexDescriptor, TVertexDescriptor>, boost::dynamic_bitset<> > & edge_ids,
int const & kmer_size
)
{
TKmerMap kmer_map;
for (Iterator<String<TVertexDescriptor const> const>::Type it = begin(order) ; it != end(order) ; ++it)
{
TVertexDescriptor const & source_vertex = *it;
if (free_nodes.count(source_vertex) == 0)
{
boost::dynamic_bitset<> id_bits(edge_ids.begin()->second.size());
id_bits.flip();
checkKmers(vertex_vector[source_vertex].dna, source_vertex, source_vertex, graph, vertex_vector, free_nodes, edge_ids, id_bits, kmer_map, static_cast<std::size_t>(kmer_size));
// std::cout << "source_vertex = " << source_vertex << " kmer_map.size() = " << kmer_map.size() << " kmer_size = " << kmer_size;
// std::cout << " vertex_vector[source_vertex].level = " << vertex_vector[source_vertex].level << std::endl;
}
}
return kmer_map;
}
void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, int player/*=-1*/, int mode/*=0*/ ) const
{
if(player >= GameConstants::PLAYER_LIMIT)
{
tlog1 << "Illegal call to getTilesInRange!\n";
return;
}
if (radious == -1) //reveal entire map
getAllTiles (tiles, player, -1, 0);
else
{
const TeamState * team = gs->getPlayerTeam(player);
for (int xd = std::max<int>(pos.x - radious , 0); xd <= std::min<int>(pos.x + radious, gs->map->width - 1); xd++)
{
for (int yd = std::max<int>(pos.y - radious, 0); yd <= std::min<int>(pos.y + radious, gs->map->height - 1); yd++)
{
double distance = pos.dist2d(int3(xd,yd,pos.z)) - 0.5;
if(distance <= radious)
{
if(player < 0
|| (mode == 1 && team->fogOfWarMap[xd][yd][pos.z]==0)
|| (mode == -1 && team->fogOfWarMap[xd][yd][pos.z]==1)
)
tiles.insert(int3(xd,yd,pos.z));
}
}
}
}
}
void writeEGDot(SmartGraph& g, SmartGraph::EdgeMap<double>& length,
ostream& out, SmartGraph::NodeMap<IndexPair>& edgePairs,
boost::unordered_set<unsigned>& matched)
{
out << "graph name {" << endl;
out << " node [ shape=ellipse, fontname=Helvetica, fontsize=10 ];" << endl;
for (SmartGraph::NodeIt n(g); n != INVALID; ++n)
{
IndexPair p = edgePairs[n];
if(p.first != p.second)
out << " n" << g.id(n) << " [ label=\"" << p.first << ":" << p.second << "\" ]; " << endl;
else
out << " n" << g.id(n) << " [ shape=triangle, label=\"" << p.first << "\" ]; \n";
}
out << " edge [ shape=ellipse, fontname=Helvetica, fontsize=10 ];" << endl;
for (SmartGraph::EdgeIt e(g); e != INVALID; ++e)
{
string extra = "";
if(matched.count(g.id(e)))
extra = "style = bold, ";
out << " n" << g.id(g.u(e)) << " -- " << " n" << g.id(g.v(e))
<< " [ " << extra << "label=\"" << length[e] << "\" ]; " << endl;
}
out << "}" << endl;
}
void CPrivilagedInfoCallback::getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, int Player/*=-1*/, int level, int surface ) const
{
if(Player >= GameConstants::PLAYER_LIMIT)
{
tlog1 << "Illegal call to getAllTiles !\n";
return;
}
bool water = surface == 0 || surface == 2,
land = surface == 0 || surface == 1;
std::vector<int> floors;
if(level == -1)
{
for(int b = 0; b < (gs->map->twoLevel ? 2 : 1); ++b)
{
floors.push_back(b);
}
}
else
floors.push_back(level);
for (std::vector<int>::const_iterator i = floors.begin(); i!= floors.end(); i++)
{
register int zd = *i;
for (int xd = 0; xd < gs->map->width; xd++)
{
for (int yd = 0; yd < gs->map->height; yd++)
{
if ((getTile (int3 (xd,yd,zd))->terType == 8 && water)
|| (getTile (int3 (xd,yd,zd))->terType != 8 && land))
tiles.insert(int3(xd,yd,zd));
}
}
}
}
inline Size Observable::unregisterObserver(Observer* o) {
// in case the observer is in the deferred notifications list
// remove it
if (settings_.updatesDeferred())
settings_.unregisterDeferredObserver(o);
return observers_.erase(o);
}
void
checkKmers(DnaString const & kmer,
TVertexDescriptor const & starting_vertex,
TVertexDescriptor const & source_vertex,
TGraph const & graph,
std::vector<VertexLabels> & vertex_vector,
boost::unordered_set<TVertexDescriptor> const & free_nodes,
boost::unordered_map< std::pair<TVertexDescriptor, TVertexDescriptor>, boost::dynamic_bitset<> > & edge_ids,
boost::dynamic_bitset<> const & id_bits,
TKmerMap & kmer_map,
std::size_t const & kmer_size
)
{
if (id_bits.none())
return;
if (length(kmer) == kmer_size)
{
KmerLabels new_kmer_label =
{
starting_vertex,
source_vertex,
id_bits
};
if (kmer_map.count(kmer) == 0)
{
std::vector<KmerLabels> new_vector(1, new_kmer_label);
kmer_map[kmer] = new_vector;
}
else
{
kmer_map[kmer].push_back(new_kmer_label);
}
return;
}
for (Iterator<TGraph, OutEdgeIterator>::Type out_edge_iterator (graph, source_vertex) ; !atEnd(out_edge_iterator) ; ++out_edge_iterator)
{
DnaString new_kmer(kmer);
TVertexDescriptor const & target_vertex = targetVertex(out_edge_iterator);
boost::dynamic_bitset<> new_id_bits(id_bits);
if (free_nodes.count(target_vertex) == 0)
{
seqan::appendValue(new_kmer, vertex_vector[target_vertex].dna);
std::pair<TVertexDescriptor, TVertexDescriptor> edge_pair(source_vertex, target_vertex);
if (edge_ids.count(edge_pair) == 1)
{
new_id_bits = id_bits & edge_ids[edge_pair];
}
}
checkKmers(new_kmer, starting_vertex, target_vertex, graph, vertex_vector, free_nodes, edge_ids, new_id_bits, kmer_map, kmer_size);
}
}