int irmo_net_socket_block_set(IrmoNetSocket **sockets,
int num_sockets,
int timeout)
{
int (*block_set)(IrmoNetSocket **sockets, int nh, int to);
int same_block_handler;
int i;
// Check if all sockets have the same block_set handler.
block_set = sockets[0]->socket_class->block_set;
same_block_handler = 1;
for (i=1; i<num_sockets; ++i) {
if (sockets[i]->socket_class->block_set != block_set) {
same_block_handler = 0;
break;
}
}
// If they all have the same handler, call it. Otherwise, just
// block on the first socket. Use a short timeout, as we will
// have to poll all the sockets.
if (same_block_handler) {
return block_set(sockets, num_sockets, timeout);
} else {
return block_set(sockets, 1, 1);
}
}
void run_impl() const {
BlockSet& bs = *block_set();
std::vector<SequencePtr> seqs = bs.seqs();
int min_length = opt_value("blast-min-length").as<int>();
std::set<std::string> names;
BOOST_FOREACH (const SequencePtr& seq, seqs) {
seq->set_description("");
if (seq->size() < min_length) {
bs.remove_sequence(seq);
} else {
if (seq->name().length() > 16) {
seq->set_name("");
}
while (seq->name().empty() ||
names.find(seq->name()) != names.end()) {
const int RAND_SEQ_NAME_LENGTH = 8;
seq->set_name(rand_name(RAND_SEQ_NAME_LENGTH));
}
names.insert(seq->name());
}
}
IsPangenome::IsPangenome() {
are_blocks_good_ = new AreBlocksGood;
are_blocks_good_->set_parent(this);
are_blocks_good_->point_bs("target=target", this);
align_ = new Align;
align_->set_parent(this);
abb_ = new AddBlastBlocks;
abb_->set_parent(this);
abb_->point_bs("target=blast-hits", this);
abb_->point_bs("other=target", this);
try_join_ = new TrySmth;
try_join_->set_parent(this);
try_join_->set_options("--smth-processor:=Joiner");
try_join_->point_bs("target=joined", this);
ASSERT_NE(try_join_->block_set(), block_set());
declare_bs("target", "Target blockset to be tested");
declare_bs("blast-hits", "Good blast hits");
declare_bs("all-blast-hits", "All blast hits");
declare_bs("non-internal-hits", "Non-internal blast hits");
declare_bs("joined", "Results of joining neighbour blocks");
}
static bool BlockCommand() /* ブロックコマンドの準備用 */
{
csr_leupdate();
block_set(&bkm);
if (blck.blkm!=BLKM_none)
blck.blkm= BLKM_none; else
{
bkm.y_st=GetLineOffset();
bkm.y_ed=bkm.y_st+1;
if (bkm.y_st != GetLastNumber())
bkm.blkm= BLKM_y; else
{
bkm.blkm= BLKM_x;
--bkm.y_ed;
bkm.x_st=0;
bkm.x_ed=strlen(GetList(GetLineOffset())->buffer);
}
}
return block_size(&bkm)>0;
}
void OverlaplessUnion::run_impl() const {
bool move = opt_value("ou-move").as<bool>();
bool filter = opt_value("ou-filter").as<bool>();
BlockSet& t = *block_set();
BlockSet& o = *other();
SetFc s2f;
s2f.add_bs(t);
Blocks blocks(o.begin(), o.end());
std::sort(blocks.begin(), blocks.end(), BlockLengthLess());
BOOST_FOREACH (Block* block, blocks) {
bool overlaps = s2f.block_has_overlap(block);
if (overlaps && filter) {
o.erase(block);
}
if (!overlaps && !filter) {
s2f.add_block(block);
if (move) {
o.detach(block);
t.insert(block);
} else {
t.insert(block->clone());
}
}
}
}
BOOST_FOREACH (std::string seq_group, seq_groups) {
SequencePtr seq = name2seq[seq_group];
if (seq) {
rows[seq.get()] = BSRow();
} else {
BOOST_FOREACH (SequencePtr seq, bs.seqs()) {
if (seq->genome() == seq_group ||
seq->chromosome() == seq_group ||
seq_group == "all") {
rows[seq.get()] = BSRow();
}
}
}
}
bsa_make_rows(rows, *block_set());
boost::scoped_ptr<TreeNode> tree((bsa_make_tree(rows)));
BSA& aln = block_set()->bsa(name);
int genomes = genomes_number(*block_set());
bsa_make_aln_by_tree(aln, rows, tree.get(), genomes);
bsa_orient(aln);
bsa_move_fragments(aln);
bsa_remove_pure_gaps(aln);
}
const char* FindBSA::name_impl() const {
return "Build blockset alignment";
}
}
void SequencesFromOther::run_impl() const {
block_set()->add_sequences(other()->seqs());
}
