Exemplo n.º 1
0
bool checkCurrentStatus(GraphX* graph1, GraphX* graph2, vector<Set_Iterator* >& currentS, int* nodesOrder, tr1::unordered_map<int, int>& selectedQueryMap)
{
	NodeX* dataGraphNode = graph2->getNodeWithID(*(currentS[currentS.size()-1]->it));
	NodeX* queryGraphNode = graph1->getNodeWithID(nodesOrder[currentS.size()-1]);

	for(tr1::unordered_map<int, void*>::iterator iter = queryGraphNode->getEdgesIterator();iter!=queryGraphNode->getEdgesEndIterator();++iter)
	{
		int otherNodeID = iter->first;
		EdgeX* edge = (EdgeX*)(iter->second);

		if(selectedQueryMap.find(otherNodeID)==selectedQueryMap.end())
			continue;

		//get the data node that the current data node should be connected with
		int dataNodeID = *(currentS[selectedQueryMap.find(otherNodeID)->second]->it);

		//check the current graph edges, whether it has a connection to dataNodeID or not
		if(!dataGraphNode->isItConnectedWithNodeID(dataNodeID, edge->getLabel()))
		{
			//cout<<"false"<<endl;
			return false;
		}
	}

	return true;
}
Exemplo n.º 2
0
string checkCache (string httpMsg) {
  
  string cacheItem;
  string cacheKey = "";
  cacheKey.append (getReqType(httpMsg));
  cacheKey.append (getUri(httpMsg));
  cacheKey.append (getHost(httpMsg));

  // Critical Section
  pthread_mutex_lock(&cacheLock);
  if (cacheMap.size() != 0) {
    try {
      tr1::unordered_map<string,string>::const_iterator got = cacheMap.find(cacheKey);
      if (got == cacheMap.end()) {
	cacheItem = "";
      } else {
	cacheItem = got->second;
      }
    } catch (...) {
      cacheItem = "";
    }
  } else {
    cacheItem = "";
  }
  pthread_mutex_unlock(&cacheLock);

  return cacheItem;
}
Exemplo n.º 3
0
void insertIntoEdgeFreq(NodeX* src, int destNodeID, double destNodeLabel, double edgeLabel, tr1::unordered_map<string, void* >& edgeToFreq, bool addSrcOnly)
{
	string key;
	if(src->getLabel()>destNodeLabel)
	{
		stringstream sstmGF;
		if(src->getLabel()==destNodeLabel)
			sstmGF << src->getLabel()<<destNodeLabel<<","<<edgeLabel<<",";
		else
			sstmGF << src->getLabel()<<","<<destNodeLabel<<","<<edgeLabel<<",";
		key = sstmGF.str();
	}
	else
	{
		stringstream sstmGF;
		if(destNodeLabel==src->getLabel())
			sstmGF <<destNodeLabel<<src->getLabel()<<","<<edgeLabel<<",";
		else
			sstmGF <<destNodeLabel<<","<<src->getLabel()<<","<<edgeLabel<<",";
		key = sstmGF.str();
	}

	tr1::unordered_map<string, void* >::iterator iter = edgeToFreq.find(key);
	Pattern* pattern;
	if(iter==edgeToFreq.end())
	{
		GraphX* graph = new GraphX();
		NodeX* node1 = graph->AddNode(0, src->getLabel());
		NodeX* node2 = graph->AddNode(1, destNodeLabel);
		graph->addEdge(node1, node2, edgeLabel);
		pattern = new Pattern(graph);
		delete graph;

		edgeToFreq[key] = pattern;
	}
	else
	{
		pattern = (Pattern*)((*iter).second);
	}

	if(pattern->getGraph()->getNodeWithID(0)->getLabel()==src->getLabel())
	{
		pattern->addNode(src->getID(), 0);
		if(!addSrcOnly) pattern->addNode(destNodeID, 1);
	}
	else
	{
		pattern->addNode(src->getID(), 1);
		if(!addSrcOnly) pattern->addNode(destNodeID, 0);
	}
}
Exemplo n.º 4
0
int main()
{
    ifstream in("oite.in");
    ofstream out("oite.out");
    int i,j,s_cr;
    int show = 0;
    in >> n >> S;
    for(i=1;i<=n;++i)
        in >> v[i];
    for(i = 1 ; i <= n ; ++ i)
    {
        for(j = i + 1 ; j <= n ; ++ j)
        {
            s_cr = S - v[i] - v[j];
            if(s_cr < 0)
                continue;
            if(sum_hash.count(s_cr))
            {
                show += sum_hash[s_cr];
            }
        }
        for(j = 1 ; j < i ; ++ j)
        {
            ++sum_hash[v[i]+v[j]];
        }
    }
    out << show;
    return 0;
}
Exemplo n.º 5
0
/**
 * load a graph from the given string. string should follow the .lg format
 */
bool GraphX::loadFromString(string data, tr1::unordered_map<string, void* >& edgeToFreq)
{
	CL.clear();

	istringstream str(data);

	bool b = parseData(str, edgeToFreq);

	//destruct data in the 'edgeToFreq' structure
	for(tr1::unordered_map<string, void* >::iterator iter = edgeToFreq.begin();iter!=edgeToFreq.end();iter++)
	{
		delete ((Pattern*)iter->second);
	}
	edgeToFreq.clear();

	if(!b)
		return false;

	return true;
}
Exemplo n.º 6
0
void addToCache (string request, string response) {
  
  string cacheKey = "";
  cacheKey.append (getReqType(request));
  cacheKey.append (getUri(request));
  cacheKey.append (getHost(request));

  // Critical Section
  pthread_mutex_lock(&cacheLock);
  try {
  if (cacheMap.size() < MAXCACHESIZE) {
    cacheMap.insert (make_pair<string, string>(cacheKey, response));
  } else {
    tr1::unordered_map<string,string>::const_iterator got = cacheMap.begin();
    cacheMap.erase (got);
    cacheMap.insert (make_pair<string, string>(cacheKey, response));
  }
  } catch (...) {
  }
  pthread_mutex_unlock(&cacheLock);
}
Exemplo n.º 7
0
bool LBIDList::GetMinMax(int64_t *min, int64_t *max, int64_t *seq,
	int64_t lbid, const tr1::unordered_map<int64_t, BRM::EMEntry> &entries,
    execplan::CalpontSystemCatalog::ColDataType colDataType)
{
	tr1::unordered_map<int64_t, BRM::EMEntry>::const_iterator it = entries.find(lbid);

	if (it == entries.end())
		return false;

	const BRM::EMEntry &entry = it->second;

	if (entry.partition.cprange.isValid != BRM::CP_VALID) {
	    MinMaxPartition *mmp;
        mmp = new MinMaxPartition();
        mmp->lbid = lbid;
        mmp->lbidmax = lbid + (entry.range.size * 1024);
        mmp->seq = entry.partition.cprange.sequenceNum;
        if (isUnsigned(colDataType))
        {
            mmp->max = 0;
            mmp->min = static_cast<int64_t>(numeric_limits<uint64_t>::max());
        }
        else
        {
            mmp->max = numeric_limits<int64_t>::min();
            mmp->min = numeric_limits<int64_t>::max();
        }
        mmp->isValid = entry.partition.cprange.isValid;
        mmp->blksScanned = 0;
        lbidPartitionVector.push_back(mmp);
		return false;
	}

	*min = entry.partition.cprange.lo_val;
	*max = entry.partition.cprange.hi_val;
	*seq = entry.partition.cprange.sequenceNum;
	return true;
}