Beispiel #1
0
void
query::begin(const render_context& in_context) const
{
    const opengl::gl_core& glapi = in_context.opengl_api();
    assert(0 != query_id());
    assert(0 != query_type());

    glapi.glBeginQuery(query_type(), query_id());

    gl_assert(glapi, leaving query::begin());
}
Beispiel #2
0
bool
query::available(const render_context& in_context) const
{
    const opengl::gl_core& glapi = in_context.opengl_api();
    assert(0 != query_id());
    assert(0 != query_type());

    int query_available = GL_FALSE;

    glapi.glGetQueryObjectiv(query_id(), GL_QUERY_RESULT_AVAILABLE, &query_available);
    
    gl_assert(glapi, leaving query::available());

    return query_available != GL_FALSE;
}
Beispiel #3
0
void
handle_query_id(MPIRPC_Node caller, int unique, char* args,
                void* blob, int blob_length)
{
  int object_id;
  sscanf(args, "%X", &object_id);
  query_id(caller, unique, object_id);
}
//------------------------------------------------------------------------------
void tracker::report_match( Uint4 queryseq, Uint4 match_count,
                            string::size_type s_off,
                            string::size_type q_off )
{
    string query_id( table.seqid( queryseq ) );
    LOG_POST( Warning << 
           "Possible duplication of sequences:\n"
        << "subject: " << subject_id << " and query: " << query_id << "\n"
        << "at intervals\n"
        << "subject: " << s_off - match_count*SAMPLE_SKIP
        << " --- " << s_off - SAMPLE_SKIP << "\n"
        << "query  : " << q_off - match_count*SAMPLE_SKIP
        << " --- " << q_off - SAMPLE_SKIP << "\n" );
}
Beispiel #5
0
vector<HitList*>* PathWalker::result()
{
	// we transform the pathwalker object to a hitlist vector
	vector<HitList*>* result;
	result = new vector<HitList*>;
	for(int i = 0; i < query_number_size(); i++)
	{
		result->push_back(new HitList());
		
		for(int j = 0; j < query_number_size(i); j++)
		{
			result->back()->add_hit(PathWalker_PathList.at(query_number(i).at(j)).target_hit(query_id(i).at(j)));
		}
	}
	
	return result;
}
ostream& operator<<(ostream& out, const CQuerySplitter& rhs)
{
    ILocalQueryData* query_data = 
        const_cast<ILocalQueryData*>(&*rhs.m_LocalQueryData);
    const size_t kNumQueries = query_data->GetNumQueries();
    const size_t kNumChunks = rhs.GetNumberOfChunks();

    out << endl << "; This is read by x_ReadQueryBoundsPerChunk" 
        << endl << "; Format: query start, query end, strand" << endl;

    // for all query indices {
    //     iterate every chunk and collect the coords, print them out
    // }
    for (size_t query_index = 0; query_index < kNumQueries; query_index++) {
        CConstRef<CSeq_id> query_id
            (query_data->GetSeq_loc(query_index)->GetId());
        _ASSERT(query_id);
        
        for (size_t chunk_index = 0; chunk_index < kNumChunks; chunk_index++) {
            CRef<CBlastQueryVector> queries_in_chunk = 
                rhs.m_SplitQueriesInChunk[chunk_index];

            for (size_t qidx = 0; qidx < queries_in_chunk->Size(); qidx++) {
                CConstRef<CSeq_loc> query_loc_in_chunk =
                    queries_in_chunk->GetQuerySeqLoc(qidx);
                _ASSERT(query_loc_in_chunk);
                CConstRef<CSeq_id> query_id_in_chunk
                    (query_loc_in_chunk->GetId());
                _ASSERT(query_id_in_chunk);

                if (query_id->Match(*query_id_in_chunk)) {
                    const CSeq_loc::TRange& range = 
                        query_loc_in_chunk->GetTotalRange();
                    out << "Chunk" << chunk_index << "Query" << query_index
                        << " = " << range.GetFrom() << ", " 
                        << range.GetToOpen() << ", " 
                        << (int)query_loc_in_chunk->GetStrand() << endl;
                }
            }
        }
        out << endl;
    }

    return out;
}
Beispiel #7
0
mapping save()
{
	ACCESS_CHECK(GAME());

	return ([
		"archetypes": query_archetypes(),
		"capacity": query_capacity(),
		"density": query_density(),
		"environment": query_environment(),
		"flexible": query_flexible(),
		"id": query_id(),
		"inventory": query_inventory(),
		"mass": query_mass(),
		"max_mass": query_max_mass(),
		"name": query_object_name(),
		"properties": query_local_properties(),
		"virtual": query_virtual()
	]);
}
Beispiel #8
0
int query_emit(plugin_t *plugin, const char *name, ...) {
	int result = -2;
	va_list ap;
	query_t *q;
	int id;

	id = query_id(name);

	va_start(ap, name);
	for (q = queries[id >= QUERY_EXTERNAL ? QUERY_EXTERNAL : id]; q; q = q->next) {
		if ((!plugin || (plugin == q->plugin)) && q->id == id) {
			result = query_emit_common(q, ap);

			if (result == -1) break;
		}
	}
	va_end(ap);
	return result;
}
Beispiel #9
0
mixed direct_drink_str_from_obj( string fluid ){
if ( !member_array( fluid+"_source", query_id() )) return "You cannot drink "+fluid+" from that.\n";
return 1;
}
Beispiel #10
0
query_t *query_connect(plugin_t *plugin, const char *name, query_handler_func_t *handler, void *data) {
	return query_connect_common(plugin, query_id(name), handler, data);
}