int MainWork ()
{
int iRetVal = 0;
std::vector<SSubscriberRefresh> vectSubscriberList;
std::vector<SSubscriberRefresh>::iterator iterSubscr;
do {
/* загружаем список абонентов */
iRetVal = CreateSubscriberList (&vectSubscriberList);
if (iRetVal) {
break;
}
if (vectSubscriberList.size() > 1000) {
iRetVal = CreateSessionListFull(g_mmapSessionListFull);
if (iRetVal) {
g_mmapSessionListFull.clear();
}
}
/* обходим список абонентов */
iterSubscr = vectSubscriberList.begin();
while (iterSubscr != vectSubscriberList.end()) {
/* обрабатыаем учетную запись абонента */
iRetVal = ThreadManager (*iterSubscr);
if (iRetVal) {
break;
}
++iterSubscr;
}
} while (0);
g_mmapSessionListFull.clear();
return iRetVal;
}
virtual void ReadAliases()
{
ConfigReader MyConf(ServerInstance);
AllowBots = MyConf.ReadFlag("fantasy", "allowbots", "no", 0);
std::string fpre = MyConf.ReadValue("fantasy","prefix",0);
fprefix = fpre.empty() ? '!' : fpre[0];
Aliases.clear();
for (int i = 0; i < MyConf.Enumerate("alias"); i++)
{
Alias a;
std::string txt;
txt = MyConf.ReadValue("alias", "text", i);
a.AliasedCommand = txt.c_str();
a.ReplaceFormat = MyConf.ReadValue("alias", "replace", i, true);
a.RequiredNick = MyConf.ReadValue("alias", "requires", i);
a.ULineOnly = MyConf.ReadFlag("alias", "uline", i);
a.ChannelCommand = MyConf.ReadFlag("alias", "channelcommand", "no", i);
a.UserCommand = MyConf.ReadFlag("alias", "usercommand", "yes", i);
a.OperOnly = MyConf.ReadFlag("alias", "operonly", i);
a.format = MyConf.ReadValue("alias", "format", i);
a.CaseSensitive = MyConf.ReadFlag("alias", "matchcase", i);
Aliases.insert(std::make_pair(txt, a));
}
}
/// Reads in the file with the grouping information
bool DiffractionFocussing::readGroupingFile(
std::string groupingFileName,
std::multimap<int64_t, int64_t> &detectorGroups) {
std::ifstream grFile(groupingFileName.c_str());
if (!grFile) {
g_log.error() << "Unable to open grouping file " << groupingFileName
<< std::endl;
return false;
}
detectorGroups.clear();
std::string str;
while (getline(grFile, str)) {
if (str.empty() || str[0] == '#')
continue;
std::istringstream istr(str);
int n, udet, sel, group;
double offset;
istr >> n >> udet >> offset >> sel >> group;
// Check the line wasn't badly formatted - return a failure if it is
// if ( ! istr.good() ) return false;
// only allow groups with +ve ids
if ((sel) && (group > 0)) {
detectorGroups.insert(std::make_pair(group, udet));
}
}
return true;
}
virtual void OnRehash(User *user)
{
ConfigReader MyConf(ServerInstance);
std::string snomasks;
std::string channel;
logstreams.clear();
for (int i = 0; i < MyConf.Enumerate("chanlog"); i++)
{
channel = MyConf.ReadValue("chanlog", "channel", i);
snomasks = MyConf.ReadValue("chanlog", "snomasks", i);
if (channel.empty() || snomasks.empty())
{
ServerInstance->Logs->Log("m_chanlog", DEFAULT, "Malformed chanlog tag, ignoring");
continue;
}
for (std::string::const_iterator it = snomasks.begin(); it != snomasks.end(); it++)
{
logstreams.insert(std::make_pair(*it, channel));
ServerInstance->Logs->Log("m_chanlog", DEFAULT, "Logging %c to %s", *it, channel.c_str());
}
}
}
static bool BuildPersistentCache()
{
if (next_persistent_id)
return true;
if (!Core::getInstance().isWorldLoaded())
return false;
stl::vector<df::historical_figure*> &hfvec = df::historical_figure::get_vector();
// Determine the next entry id as min(-100, lowest_id-1)
next_persistent_id = -100;
if (hfvec.size() > 0 && hfvec[0]->id <= -100)
next_persistent_id = hfvec[0]->id-1;
// Add the entries to the lookup table
persistent_index.clear();
for (size_t i = 0; i < hfvec.size() && hfvec[i]->id <= -100; i++)
{
if (!hfvec[i]->name.has_name || hfvec[i]->name.first_name.empty())
continue;
persistent_index.insert(T_persistent_item(hfvec[i]->name.first_name, -hfvec[i]->id));
}
return true;
}
void GroupTransformer::putData(RddPartition* output,
std::multimap<PbMessagePtr, PbMessagePtr, idgs::store::less>& localCache) {
if (!localCache.empty()) {
PbMessagePtr key;
std::vector<PbMessagePtr> values;
for (auto it = localCache.begin(); it != localCache.end(); ++it) {
if (idgs::store::equals_to()(const_cast<PbMessagePtr&>(it->first), key)) {
values.push_back(it->second);
} else {
if (!values.empty()) {
output->put(key, values);
values.clear();
}
values.clear();
key = it->first;
values.push_back(it->second);
}
}
if (!values.empty()) {
output->put(key, values);
values.clear();
}
localCache.clear();
}
}
/// @brief distribute matched phrase by names
/// @param phrases vector with matched phrases [in]
/// @param phraseByCls classID to phrase_matched multimap [out]
// this impementatin doesn't use getClasses (by ids) since huge multimap overhead
void PhraseSearcher::getClasses(const vector<phrase_matched> &phrases,
std::multimap<string, phrasecls_matched> &phraseByCls) const
{
phraseByCls.clear();
phrasecls_matched mi;
phrase_record *phrec;
phrase_classes_list *pclassList;
for (vector<phrase_matched>::const_iterator it = phrases.begin();
it != phrases.end();
it++)
{
phrec = m_pimpl->m_phrase_offsets[ it->phrase_id ];
pclassList = __phrase_header_jump_to_classes(phrec);
mi.phrase_id = it->phrase_id;
mi.match_flags = it->match_flags;
for (unsigned i = 0; i < pclassList->n; i++) {
mi.baserank = pclassList->clse[i].phrase_rank;
phraseByCls.insert(pair<string, phrasecls_matched>(m_pQCIndex->getName(pclassList->clse[i].clsid), mi));
}
}
}
CServerDefinitions::CServerDefinitions() : defaultPriority( 0 )
{
Console.PrintSectionBegin();
Console << "Loading server scripts..." << myendl;
Console << " o Clearing AddMenuMap entries(" << g_mmapAddMenuMap.size() << ")" << myendl;
g_mmapAddMenuMap.clear();
ScriptListings.resize( NUM_DEFS );
ReloadScriptObjects();
Console.PrintSectionBegin();
}
void IOracle::sortedColumns(
std::multimap<Double, Column const *, std::greater<Double>> & result) const {
result.clear();
// MY_PRINT(_columns.size());
for (auto const & column : _columns) {
// column.print();
ASSERT_CHECK(column.check(*_dual));
result.insert(std::make_pair(column.reducedCost(), &column));
}
}
bool MDFN_SaveSettings(void)
{
std::multimap <uint32, MDFNCS>::iterator sit;
std::list<MDFNCS *> SortedList;
std::list<MDFNCS *>::iterator lit;
FILE *fp;
if(!(fp = fopen(fname.c_str(), "wb")))
return(0);
trio_fprintf(fp, ";VERSION %s\n", MEDNAFEN_VERSION);
trio_fprintf(fp, _(";Edit this file at your own risk!\n"));
trio_fprintf(fp, _(";File format: <key><single space><value><LF or CR+LF>\n\n"));
for(sit = CurrentSettings.begin(); sit != CurrentSettings.end(); sit++)
{
SortedList.push_back(&sit->second);
//trio_fprintf(fp, ";%s\n%s %s\n\n", _(sit->second.desc->description), sit->second.name, sit->second.value);
//free(sit->second.name);
//free(sit->second.value);
}
SortedList.sort(compare_sname);
for(lit = SortedList.begin(); lit != SortedList.end(); lit++)
{
if((*lit)->desc->type == MDFNST_ALIAS)
continue;
trio_fprintf(fp, ";%s\n%s %s\n\n", _((*lit)->desc->description), (*lit)->name, (*lit)->value);
free((*lit)->name);
free((*lit)->value);
}
if(UnknownSettings.size())
{
trio_fprintf(fp, "\n;\n;Unrecognized settings follow:\n;\n\n");
for(unsigned int i = 0; i < UnknownSettings.size(); i++)
{
trio_fprintf(fp, "%s %s\n\n", UnknownSettings[i].name, UnknownSettings[i].value);
free(UnknownSettings[i].name);
free(UnknownSettings[i].value);
}
}
CurrentSettings.clear(); // Call after the list is all handled
UnknownSettings.clear();
fclose(fp);
return(1);
}
void node_t::cmp_scores(std::multimap<double,int> &scores, descriptor_t *data)
{
scores.clear();
for (unsigned i=0; i<nb_branches; i++) {
if (clusters[i]) {
double d = clusters[i]->mean.distance(data);
//if (!finite(d)) std::cout << "dist= " << d << std::endl;
scores.insert(std::pair<double,int>(d,i));
}
}
}
//o--------------------------------------------------------------------------o
//| Function/Class - bool CServerDefinitions::Reload( void )
//| Date - 04/17/2002
//| Developer(s) - EviLDeD
//| Company/Team - UOX3 DevTeam
//| Status -
//o--------------------------------------------------------------------------o
//| Description - Reload the dfn files.
//| Modification - 04042004 - EviLDeD - Added the code to clear out the
//| Auto-AddMenu items so there isn't any duplication in the
//| multimap
//o--------------------------------------------------------------------------o
//| Returns - [TRUE] if succesfull
//o--------------------------------------------------------------------------o
bool CServerDefinitions::Reload( void )
{
// We need to clear out the AddMenuItem Map
g_mmapAddMenuMap.clear();
//
Cleanup();
ScriptListings.clear();
ScriptListings.resize( NUM_DEFS );
ReloadScriptObjects();
return true;
}
void UpdateHashToFunctionMap() {
lock_guard guard(functions_lock);
hashToFunction.clear();
// Really need to detect C++11 features with better defines.
#if !defined(__SYMBIAN32__) && !defined(IOS)
hashToFunction.reserve(functions.size());
#endif
for (auto iter = functions.begin(); iter != functions.end(); iter++) {
AnalyzedFunction &f = *iter;
if (f.hasHash && f.size > 16) {
hashToFunction.insert(std::make_pair(f.hash, &f));
}
}
}
static void cancel_timers(std::multimap<int,int> &timers)
{
using Lua::Core::State;
Lua::StackUnwinder frame(State);
lua_rawgetp(State, LUA_REGISTRYINDEX, &DFHACK_TIMEOUTS_TOKEN);
for (auto it = timers.begin(); it != timers.end(); ++it)
{
lua_pushnil(State);
lua_rawseti(State, frame[1], it->second);
}
timers.clear();
}
template <typename PointT> void
pcl::SupervoxelClustering<PointT>::getSupervoxelAdjacency (std::multimap<uint32_t, uint32_t> &label_adjacency) const
{
label_adjacency.clear ();
for (typename HelperListT::const_iterator sv_itr = supervoxel_helpers_.cbegin (); sv_itr != supervoxel_helpers_.cend (); ++sv_itr)
{
uint32_t label = sv_itr->getLabel ();
std::set<uint32_t> neighbor_labels;
sv_itr->getNeighborLabels (neighbor_labels);
for (std::set<uint32_t>::iterator label_itr = neighbor_labels.begin (); label_itr != neighbor_labels.end (); ++label_itr)
label_adjacency.insert (std::pair<uint32_t,uint32_t> (label, *label_itr) );
//if (neighbor_labels.size () == 0)
// std::cout << label<<"(size="<<sv_itr->size () << ") has "<<neighbor_labels.size () << "\n";
}
}
void ForgetFunctions(u32 startAddr, u32 endAddr) {
lock_guard guard(functions_lock);
// It makes sense to forget functions as modules are unloaded but it breaks
// the easy way of saving a hashmap by unloading and loading a game. I added
// an alternative way.
// Most of the time, functions from the same module will be contiguous in functions.
FunctionsVector::iterator prevMatch = functions.end();
size_t originalSize = functions.size();
for (auto iter = functions.begin(); iter != functions.end(); ++iter) {
const bool hadPrevMatch = prevMatch != functions.end();
const bool match = iter->start >= startAddr && iter->start <= endAddr;
if (!hadPrevMatch && match) {
// Entering a range.
prevMatch = iter;
} else if (hadPrevMatch && !match) {
// Left a range.
iter = functions.erase(prevMatch, iter);
prevMatch = functions.end();
}
}
if (prevMatch != functions.end()) {
// Cool, this is the fastest way.
functions.erase(prevMatch, functions.end());
}
RestoreReplacedInstructions(startAddr, endAddr);
if (functions.empty()) {
hashToFunction.clear();
} else if (originalSize != functions.size()) {
UpdateHashToFunctionMap();
}
}
void clear() { m_functions.clear(); }
void World::ClearPersistentCache()
{
next_persistent_id = 0;
persistent_index.clear();
}
void mem_alloc_clear_stats()
{
for (auto& item : stats)
free(item.second.StackTrace);
stats.clear();
}
/*
* dissect/print packet
*/
void
got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{
static int count = 1; /* packet counter */
/* declare pointers to packet headers */
const struct sniff_ethernet *ethernet; /* The ethernet header [1] */
const struct sniff_ip *ip; /* The IP header */
const struct sniff_tcp *tcp; /* The TCP header */
//const char *payload; /* Packet payload */
//const u_char *payload;
int size_ip;
int size_tcp;
int size_payload;
//printf("\nPacket number %d:\n", count);
count++;
/* define ethernet header */
ethernet = (struct sniff_ethernet*)(packet);
/* define/compute ip header offset */
ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
size_ip = IP_HL(ip)*4;
if (size_ip < 20) {
printf(" * Invalid IP header length: %u bytes\n", size_ip);
return;
}
/* print source and destination IP addresses */
//printf(" From: %s\n", inet_ntoa(ip->ip_src));
//printf(" To: %s\n", inet_ntoa(ip->ip_dst));
/* determine protocol */
switch(ip->ip_p) {
case IPPROTO_TCP:
//printf(" Protocol: TCP\n");
break;
case IPPROTO_UDP:
printf(" Protocol: UDP\n");
return;
case IPPROTO_ICMP:
printf(" Protocol: ICMP\n");
return;
case IPPROTO_IP:
printf(" Protocol: IP\n");
return;
default:
printf(" Protocol: unknown\n");
return;
}
/* define/compute tcp header offset */
tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
size_tcp = TH_OFF(tcp)*4;
if (size_tcp < 20) {
printf(" * Invalid TCP header length: %u bytes\n", size_tcp);
return;
}
std::string flags;
if (tcp->th_flags & TH_FIN)
flags = flags + "F";
if (tcp->th_flags & TH_SYN)
flags = flags + "S";
if (tcp->th_flags & TH_RST)
flags = flags + "R";
if (tcp->th_flags & TH_ACK)
flags = flags + "A";
if (tcp->th_flags & TH_URG)
flags = flags + "U";
if (tcp->th_flags & TH_ECE)
flags = flags + "E";
if (tcp->th_flags & TH_CWR)
flags = flags + "C";
chars v;
chars buffer;
std::multimap<u_int,chars> temp_map; //to sort
std::cout << "Packet# " << count << " S " << ntohl(tcp->th_seq) << " A " << ntohl(tcp->th_ack) << " Flags " << flags <<"\n";
if ((tcp->th_flags & TH_ACK) != 0) {
const u_char *payload = (const u_char *) (packet + SIZE_ETHERNET + size_ip + size_tcp);
size_payload = ntohs(ip->ip_len)- (size_ip + size_tcp);
std::copy(payload, payload + size_payload, std::back_inserter(v));
//std::reverse(v.begin(),v.end()); // byte order thing
std::pair<u_int,chars> temp(ntohl(tcp->th_seq),v); // create record
dict.insert(std::pair<u_int,record>(ntohl(tcp->th_ack),temp));
//std::cout << "Packet# " << count << " " << ntohl(tcp->th_seq) << "\n";
//std::cout << "Packet# " << count << " " << inet_ntoa(ip->ip_src) << "\n";
}
if (((tcp->th_flags & TH_FIN) != 0) && ((tcp->th_flags & TH_ACK) != 0)) {
std::set<u_int> temp = get_keys(dict);
u_int last_key = ntohl(tcp->th_ack);
std::cout << "*********************************************\n";
std::set<u_int>::iterator it = temp.begin();
for(;it != temp.end(); ++it)
std::cout << "Key " << *it << " Count " << dict.count(*it) <<"\n";
u_int image_key = get_max_key(dict,temp);
std::cout << "Image key " << image_key << "\n";
std::multimap<u_int,record>::iterator itt;
std::cout << "*********************************************\n";
for(itt=dict.begin(); itt!= dict.end(); ++itt) {
if ((*itt).first == image_key) {
std::pair<u_int,chars> temp_record = (*itt).second;
temp_map.insert(std::pair<u_int,chars>(temp_record.first,temp_record.second));
}
}
std::multimap<u_int,chars>::iterator ittt;
for(ittt = temp_map.begin(); ittt!=temp_map.end(); ++ittt) {
buffer.insert(buffer.end(), (*ittt).second.begin(), (*ittt).second.end());
}
std::ofstream myfile;
myfile.open("image.jpg", std::ios::out | std::ios::binary);
myfile.write(&buffer[0], buffer.size());
std::cout << buffer.size() << "\n";
std::cout << "For FIN packet " << "S: " << ntohl(tcp->th_seq) << " A: " << ntohl(tcp->th_ack) << "\n";
dict.clear();
conn.set("server_ip",inet_ntoa(ip->ip_src));
//exit(0);
}
return;
}
JNIEXPORT void JNICALL Java_jp_kanagawa_kawasaki_photokuri_PhotoKuri_clearGray(JNIEnv * env, jobject obj, jobject bitmapcolor,jobject bitmapgray,jobject bitmapover,jobject bitmapunder,jobject bitmaplaplac,double sgm)
{
AndroidBitmapInfo infocolor;
void* pixelscolor;
void* save_pixelscolor;
AndroidBitmapInfo infogray;
void* pixelsgray;
void* save_pixelsgray;
AndroidBitmapInfo infoover;
void* pixelsover;
void* save_pixelsover;
AndroidBitmapInfo infounder;
void* pixelsunder;
void* save_pixelsunder;
AndroidBitmapInfo infolaplac;
void* pixelslaplac;
void* save_pixelslaplac;
int ret;
if ((ret = AndroidBitmap_getInfo(env, bitmapcolor, &infocolor)) < 0) {
return;
}
if ((ret = AndroidBitmap_getInfo(env, bitmapgray, &infogray)) < 0) {
return;
}
if ((ret = AndroidBitmap_getInfo(env, bitmapover, &infoover)) < 0) {
return;
}
if ((ret = AndroidBitmap_getInfo(env, bitmapunder, &infounder)) < 0) {
return;
}
if ((ret = AndroidBitmap_getInfo(env, bitmaplaplac, &infolaplac)) < 0) {
return;
}
if (infocolor.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
return;
}
if (infogray.format != ANDROID_BITMAP_FORMAT_A_8) {
return;
}
if (infoover.format != ANDROID_BITMAP_FORMAT_A_8) {
return;
}
if (infounder.format != ANDROID_BITMAP_FORMAT_A_8) {
return;
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapcolor, &pixelscolor)) < 0) {
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapgray, &pixelsgray)) < 0) {
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapover, &pixelsover)) < 0) {
}
if ((ret = AndroidBitmap_lockPixels(env, bitmapunder, &pixelsunder)) < 0) {
}
if ((ret = AndroidBitmap_lockPixels(env, bitmaplaplac, &pixelslaplac)) < 0) {
}
//Save
save_pixelscolor=pixelscolor;
save_pixelsgray=pixelsgray;
save_pixelsover=pixelsover;
save_pixelsunder=pixelsunder;
save_pixelslaplac=pixelslaplac;
//pixelscolor=save_pixelscolor;
graydone(infocolor, pixelscolor, infogray, pixelsgray);
pixelscolor=save_pixelscolor;
graydone(infocolor, pixelscolor, infoover, pixelsover);
pixelscolor=save_pixelscolor;
graydone(infocolor, pixelscolor, infounder, pixelsunder);
pixelscolor=save_pixelscolor;
graydone(infocolor, pixelscolor, infolaplac, pixelslaplac);
pixelscolor=save_pixelscolor;
AndroidBitmap_unlockPixels(env, bitmapcolor);
/*http://imagingsolution.blog107.fc2.com/blog-entry-165.html���sigma��0.8���̗p*/
double sigma=sgm;
DifferenceOfGaussianFunc *differenceOfGaussianFunc;
differenceOfGaussianFunc = new DifferenceOfGaussianFunc(sigma,1);
pixelsgray=save_pixelsgray;
gaussian(differenceOfGaussianFunc,infogray,pixelsgray);
/*Over*/
sigma=sgm+0.2;
DifferenceOfGaussianFunc *differenceOfGaussianFuncOver;
differenceOfGaussianFuncOver = new DifferenceOfGaussianFunc(sigma,1);
pixelsover=save_pixelsover;
gaussian(differenceOfGaussianFuncOver,infoover,pixelsover);
/*Under*/
sigma=sgm-0.2;
DifferenceOfGaussianFunc *differenceOfGaussianFuncUnder;
differenceOfGaussianFuncUnder = new DifferenceOfGaussianFunc(sigma,1);
pixelsunder=save_pixelsunder;
gaussian(differenceOfGaussianFuncUnder,infounder,pixelsunder);
/*Laplac*/
sigma=sgm;
DifferenceOfGaussianFunc *differenceOfGaussianFuncLaplac;
differenceOfGaussianFuncLaplac = new DifferenceOfGaussianFunc(sigma,1);
pixelslaplac=save_pixelslaplac;
gaussian(differenceOfGaussianFuncLaplac,infolaplac,pixelslaplac);
lenamap = (char *)malloc(infogray.height * infogray.width);
memset(lenamap,'x',infogray.height * infogray.width);
cntr.clear();
pixelsgray=save_pixelsgray;
for (int y=1;y<infogray.height-1;y++) {
for (int x=1;x<infogray.width-1;x++) {
if(strncmp(lenamap+(infogray.width*y)+x, "o", 1) != 0){
strncpy(lenamap+(infogray.width*y)+x,"o",1);
find_maximal(x,y,pixelsgray,pixelsover,pixelsunder,infogray);
}
}
pixelsgray = (char *) pixelsgray + infogray.stride;
}
/* test */
pixelsgray=save_pixelsgray;
std::multimap<int,int>::iterator it = cntr.begin();
for (int y=1;y<infogray.height-1;y++) {
uint8_t * grayline = (uint8_t *) pixelsgray;
/*for(int x=1;x<infogray.width-1;x++){
grayline[x]=255;
}*/
//g(differenceOfGaussianFuncUnder,infounder,pixelsunder,(*it).first,(*it).second);
if(y==(*it).first){
while(y==(*it).first){
if(0==g(differenceOfGaussianFuncUnder,infounder,pixelsunder,(*it).first,(*it).second)){
grayline[(*it).second]=255;
}else{
grayline[(*it).second]=0;
}
it++;
}
}else{
++it;
}
pixelsgray = (char *) pixelsgray + infogray.stride;
}
make_orientation(infolaplac,pixelslaplac,cntr);
AndroidBitmap_unlockPixels(env, bitmapgray);
AndroidBitmap_unlockPixels(env, bitmapover);
AndroidBitmap_unlockPixels(env, bitmapunder);
//free(lenamap);������
}
bool gpl::xml::getXPathResultSet(std::multimap<std::string, std::string>& resultSet)
{
resultSet.clear();
//added by shandy 20041208
if (m_xml->resource == NULL)
return true;
std::vector<std::string> strVector;
std::string str, name;
int i;
xmlNodeSetPtr tmpPtr = 0;
//cout<<"resource->type:"<<m_xml->resource->type<<endl;
switch (m_xml->resource->type)
{
case XPATH_UNDEFINED://Object is uninitialized
return false;
break;
case XPATH_NODESET://Object is a Node Set
tmpPtr = m_xml->resource->nodesetval;
if (tmpPtr == NULL)
break;
for (i = 0; i < tmpPtr->nodeNr; i++)
m_xml->getDumpNode(tmpPtr->nodeTab[i], resultSet);
break;
case XPATH_XSLT_TREE://Object is an XSLT value tree
return false;
break;
case XPATH_BOOLEAN://Object is a Boolean
str = m_xml->getStringByXmlCharPtr(xmlXPathCastBooleanToString(m_xml->resource->boolval), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("boolean"), str));
break;
case XPATH_NUMBER://Object is a number
str = m_xml->getStringByXmlCharPtr(xmlXPathCastNumberToString(m_xml->resource->floatval), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("number"), str));
break;
case XPATH_STRING://Object is a string
if (m_xml->resource->stringval != NULL)
{
std::string str = m_xml->getStringByXmlCharPtr(m_xml->resource->stringval);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("string"), str));
}
break;
case XPATH_POINT://Object is a point
//fprintf(output, " : index %d in node", m_xml->resource->index);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
break;
case XPATH_RANGE:
if ((m_xml->resource->user2 == NULL) ||
((m_xml->resource->user2 == m_xml->resource->user) && (m_xml->resource->index == m_xml->resource->index2)))
{
//Object is a collapsed range
//if (m_xml->resource->index >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index);
//fprintf(output, "node\n");
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
}
else
{
//Object is a range from
//if (m_xml->resource->index >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
// to
//if (m_xml->resource->index2 >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index2);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user2, resultSet);
}
break;
case XPATH_LOCATIONSET://Object is a Location Set
return false;
break;
case XPATH_USERS://Object is user defined
return false;
break;
}
return true;
}
int readFile(const string &filename,
std::vector<Interaction> &vecInteractions,
std::multimap<size_t, size_t> &mapUserID2Index,
std::multimap<size_t, size_t> &mapAdID2Index,
std::map<size_t, std::set<size_t> > &mapUserID2AdIDSet){
//init
vecInteractions.clear();
mapUserID2Index.clear();
mapAdID2Index.clear();
#ifdef DEBUG
time_t t1, t2;
t1 = time(NULL);
std::cout<<"start loading file\n";
std::cout.flush();
#endif
//file descriptor
int fd;
//file info
struct stat fileState;
int status;
size_t fileSize;
//the memory-mapped thing itself
void *mapped;
//open file for reading
try{
fd = open(filename.c_str(), O_RDONLY);
if(fd < 0){
throw("failed to open file\n");
}
}catch(const char* msg){
std::cout<<msg<<std::endl;
std::cout.flush();
return -1;
}
status = fstat(fd, & fileState);
if(status){
std::cout<<"failed to get file status\n";
}
fileSize = fileState.st_size;
//memory-map the file
try{
//mapped = mmap(0, fileSize, PROT_READ, MAP_PRIVATE| MAP_POPULATE, fd, 0);
mapped = mmap(0, fileSize, PROT_READ | MAP_POPULATE | MAP_HUGETLB, MAP_SHARED, fd, 0);
if(mapped == MAP_FAILED){
throw("failed to map file\n");
}
}catch(const char* msg){
std::cout<<msg<<std::endl;
std::cout.flush();
return -1;
}
madvise(mapped, fileSize, MADV_SEQUENTIAL|MADV_WILLNEED);
#ifdef DEBUG
std::cout<<"start conuting line\n";
#endif
//count line num
char *ptr = (char*)mapped;
size_t nChrCnt = 0;
size_t nLineNum = 0;
for(; nChrCnt < fileSize; ++nChrCnt){
if(*ptr == '\n'){
++nLineNum;
}
++ptr;
}
nChrCnt = 0;
ptr = static_cast<char*>(mapped);
vecInteractions.resize(nLineNum);
#ifdef DEBUG
t2 = time(NULL);
std::cout << "line num " << nLineNum << " time used " << t2-t1 << "sec \n";
std::cout.flush();
#endif
//map userid to its adList
std::map<size_t, std::set<size_t> >::iterator iter;
size_t nLineCnt = 0;
while(1){
int nEndPos = 0;
while((nChrCnt < fileSize) && (ptr[nEndPos] != '\n')){
++nEndPos;
++nChrCnt;
}
// Interaction interaction(ptr, ptr+nEndPos);
// vecInteractions.push_back(interaction);
// mapUserID2Index.insert(std::pair<size_t, size_t>(interaction.userID, nCnt));
// mapAdID2Index.insert(std::pair<size_t, size_t>(interaction.adID, nCnt));
vecInteractions[nLineCnt].init(ptr, ptr+nEndPos);
mapUserID2Index.insert(std::pair<size_t, size_t>(vecInteractions[nLineCnt].userID, nLineCnt));
mapAdID2Index.insert(std::pair<size_t, size_t>(vecInteractions[nLineCnt].adID, nLineCnt));
iter = mapUserID2AdIDSet.find(vecInteractions[nLineCnt].userID);
if(iter != mapUserID2AdIDSet.end()){
(iter->second).insert(vecInteractions[nLineCnt].adID);
}else{
std::set<size_t> adIDset;
adIDset.insert(vecInteractions[nLineCnt].adID);
mapUserID2AdIDSet.insert(std::pair<size_t, std::set<size_t> >(vecInteractions[nLineCnt].userID, adIDset));
}
#ifdef DEBUG
if(nLineCnt%1000000 == 0){
t2 = time(NULL);
std::cout << (double)nLineCnt*100/nLineNum << "% loaded. used time " << t2-t1 << "sec \n";
std::cout.flush();
}
#endif
++nEndPos;
++nChrCnt;
++nLineCnt;
if(nChrCnt >= fileSize){
break;
}
ptr = ptr + nEndPos;
}
//close file and file mapping
try{
if(munmap(mapped, fileSize)){
throw("failed to unmapping file\n");
}
if(close(fd)){
throw("failed to close file\n");
}
}catch(const char *msg){
std::cout<<msg<<std::endl;
std::cout.flush();
return -1;
}
#ifdef DEBUG
t2 = time(NULL);
std::cout<<"loading compeleted, used "<< t2-t1 << "sec \n";
#endif
return 0;
}
void LoadSettings()
{
// The path to the configuration file.
char szCurDir[MAX_PATH];
GetCurrentDirectory(sizeof(szCurDir), szCurDir);
string scPluginCfgFile = string(szCurDir) + "\\flhook_plugins\\event.cfg";
INI_Reader ini;
set_mapCargoMissions.clear();
set_mapNpcMissions.clear();
if (ini.open(scPluginCfgFile.c_str(), false))
{
while (ini.read_header())
{
if (ini.is_header("General"))
{
while (ini.read_value())
{
if (ini.is_value("debug"))
{
set_iPluginDebug = ini.get_value_int(0);
}
else if (ini.is_value("cargo"))
{
CARGO_MISSION mis;
mis.nickname = ini.get_value_string(0);
mis.base = CreateID(ini.get_value_string(1));
mis.item = CreateID(ini.get_value_string(2));
mis.required_amount = ini.get_value_int(3);
set_mapCargoMissions.insert(multimap<uint, CARGO_MISSION>::value_type(mis.base, mis));
}
else if (ini.is_value("npc"))
{
NPC_MISSION mis;
mis.nickname = ini.get_value_string(0);
mis.system = CreateID(ini.get_value_string(1));
mis.sector = ini.get_value_string(2);
pub::Reputation::GetReputationGroup(mis.reputation, ini.get_value_string(3));
mis.required_amount = ini.get_value_int(4);
set_mapNpcMissions.insert(multimap<uint, NPC_MISSION>::value_type(mis.reputation, mis));
}
}
}
ini.close();
}
if (set_iPluginDebug&1)
{
ConPrint(L"CargoMissionSettings loaded [%d]\n",set_mapCargoMissions.size());
ConPrint(L"NpcMissionSettings loaded [%d]\n",set_mapNpcMissions.size());
}
ini.close();
}
// Read the last saved event status
char szDataPath[MAX_PATH];
GetUserDataPath(szDataPath);
string scStatsPath = string(szDataPath) + "\\Accts\\MultiPlayer\\event_stats.txt";
if (ini.open(scStatsPath.c_str(), false))
{
while (ini.read_header())
{
if (ini.is_header("Missions"))
{
while (ini.read_value())
{
if (ini.is_value("cargo"))
{
string nickname = ini.get_value_string(0);
int curr_amount = ini.get_value_int(2);
for (multimap<uint, CARGO_MISSION>::iterator i = set_mapCargoMissions.begin();
i != set_mapCargoMissions.end(); ++i)
{
if (i->second.nickname == nickname)
{
i->second.curr_amount = curr_amount;
}
}
}
else if (ini.is_value("npc"))
{
NPC_MISSION mis;
string nickname = ini.get_value_string(0);
int curr_amount = ini.get_value_int(2);
for (multimap<uint, NPC_MISSION>::iterator i = set_mapNpcMissions.begin();
i != set_mapNpcMissions.end(); ++i)
{
if (i->second.nickname == nickname)
{
i->second.curr_amount = curr_amount;
}
}
}
}
}
}
ini.close();
}
}
int main(int argc, char **argv)
{
long int i, N;
bool already_invaded;
short int L, j, k, l;
double pc = 0.49;
L = atoi(argv[1]);
N = L*L;
for(j=-L/2; j < L/2; j++)
{
for(k=-L/2+1; k < L/2+1; k++)
{
Site loc = std::make_pair(j, k);
unitCell_Square cell;
lattice.insert(std::make_pair(loc, cell));
}
}
Site start = std::make_pair(0,0);
lattice[start].is_invaded = true;
add_new_Bonds(start);
try
{
for (i=0; i<N;)
{
std::multimap<double, Bond>::iterator weakest;
weakest = accessible_Bonds.begin();
already_invaded = invade_bond(weakest->second);
if(!already_invaded)
{
i++;
}
accessible_Bonds.erase(weakest);
}
std::multimap<double, Bond>::iterator weakest = accessible_Bonds.begin();
cluster.push_back(weakest->second);
}
catch (std::exception& e) {}
std::ofstream toFile1("fractures.txt", std::ios::trunc);
std::ofstream toFile2("trapped.txt", std::ios::trunc);
toFile1 << cluster.size() << "\n";
toFile2 << trappedBonds.size() << "\n";
toFile1 << "Invasion for: temp" << "\n";
toFile2 << "Trapping for: temp" << "\n";
toFile1.precision(17);
toFile2.precision(17);
Bond current_Line;
while (!cluster.empty())
{
current_Line = cluster.front();
cluster.pop_front();
toFile1 << get_strength(current_Line) << "\t";
toFile1 << current_Line.first.first << "\t";
toFile1 << current_Line.first.second << "\t";
Site other_end = get_end(current_Line);
toFile1 << other_end.first << "\t";
toFile1 << other_end.second << "\n";
}
while (!trappedBonds.empty())
{
current_Line = trappedBonds.front();
trappedBonds.pop_front();
toFile2 << get_strength(current_Line) << "\t";
toFile2 << current_Line.first.first << "\t";
toFile2 << current_Line.first.second << "\t";
Site other_end = get_end(current_Line);
toFile2 << other_end.first << "\t";
toFile2 << other_end.second << "\n";
}
toFile1.close();
toFile2.close();
accessible_Bonds.clear();
for(j=-L/2; j < L/2; j++)
{
for(k=-L/2+1; k < L/2+1; k++)
{
for(l=0; l<2; l++)
{
Site loc = std::make_pair(j, k);
Bond bond = std::make_pair(loc, l);
accessible_Bonds.insert(std::make_pair(lattice[loc].bonds[l], bond));
}
}
}
std::multimap<double, Bond>::iterator weakest = accessible_Bonds.begin();
while(weakest->first < pc)
{
lattice[weakest->second.first].is_open[weakest->second.second] = grow_clusters(weakest->second);
accessible_Bonds.erase(weakest);
weakest = accessible_Bonds.begin();
}
unitCell_Square * current_cell;
for(j=-L/2; j < L/2; j++)
{
for(k=-L/2+1; k < L/2+1; k++)
{
current_cell = &lattice[std::make_pair(j,k)];
current_cell->clusterN = find(current_cell->clusterN);
}
}
long int bond_count = 0;
for(lattice_iterator iter = lattice.begin(); iter != lattice.end(); iter++)
{
current_cell = &iter->second;
if(current_cell->is_open[0])
{
bond_count++;
}
if(current_cell->is_open[1])
{
bond_count++;
}
}
std::ofstream toFile3("clusters.txt", std::ios::trunc);
toFile3 << bond_count << "\n";
unitCell_Square Line;
Site begin;
Site other_end;
std::map<unsigned int, unsigned int> cluster_sizes;
while (!lattice.empty())
{
begin = lattice.begin()->first;
Line = lattice.begin()->second;
lattice.erase(begin);
if(Line.is_open[0])
{
if(cluster_sizes.count(Line.clusterN) > 0)
{
cluster_sizes[Line.clusterN]++;
}
else
{
cluster_sizes.insert(std::make_pair(Line.clusterN,1));
}
toFile3 << Line.clusterN << "\t";
toFile3 << begin.first << "\t";
toFile3 << begin.second << "\t";
other_end = get_end(std::make_pair(begin, 0));
toFile3 << other_end.first << "\t";
toFile3 << other_end.second << "\n";
}
if(Line.is_open[1])
{
if(cluster_sizes.count(Line.clusterN) > 0)
{
cluster_sizes[Line.clusterN]++;
}
else
{
cluster_sizes.insert(std::make_pair(Line.clusterN,1));
}
toFile3 << Line.clusterN << "\t";
toFile3 << begin.first << "\t";
toFile3 << begin.second << "\t";
other_end = get_end(std::make_pair(begin, 1));
toFile3 << other_end.first << "\t";
toFile3 << other_end.second << "\n";
}
}
toFile3.close();
unsigned int largest_cluster = 0;
unsigned int largest_cluster_size = 0;
std::map<unsigned int, unsigned int>::iterator iter;
for(iter = cluster_sizes.begin(); iter != cluster_sizes.end(); iter++)
{
if(iter->second > largest_cluster_size)
{
largest_cluster = iter->first;
largest_cluster_size = iter->second;
}
}
std::map<unsigned int, unsigned int> cluster_count;
unsigned int size, begin2;
while (!cluster_sizes.empty())
{
begin2 = cluster_sizes.begin()->first;
size = cluster_sizes.begin()->second;
cluster_sizes.erase(begin2);
if(cluster_count.count(size) > 0)
{
cluster_count[size]++;
}
else
{
cluster_count.insert(std::make_pair(size, 1));
}
}
std::ofstream toFile4("cluster_distribution.txt", std::ios::trunc);
toFile4 << cluster_count.size() << "\t" << largest_cluster << "\t";
toFile4 << cluster_map[largest_cluster].second.first << "\t" << cluster_map[largest_cluster].second.second << "\n";
unsigned int count;
while (!cluster_count.empty())
{
size = cluster_count.begin()->first;
count = cluster_count.begin()->second;
cluster_count.erase(size);
toFile4 << size << "\t" << count << "\n";
}
toFile4.close();
return 0;
}
void Reset() {
lock_guard guard(functions_lock);
functions.clear();
hashToFunction.clear();
}
