void Motif::read(istream& motin) {
char line[200];
vector<int> c;
vector<int> p;
vector<bool> s;
// Read sites
// (don't add yet, as they will get screwed up by the column changes)
while(motin.getline(line, 200)) {
if(line[0] == '*') break;
strtok(line, "\t");
c.push_back(atoi(strtok(NULL, "\t")));
p.push_back(atoi(strtok(NULL, "\t")));
s.push_back(atoi(strtok(NULL, "\0")));
}
int motwidth = strlen(line);
columns.clear();
for(int i = 0; i < motwidth; i++) {
if(line[i] == '*') add_col(i);
}
// Add sites
sitelist.clear();
int num_sites = c.size();
for(int i = 0; i < num_sites; i++) {
assert(p[i] >= 0);
add_site(c[i], p[i], s[i]);
}
// Read MAP score
motin.getline(line, 200);
strtok(line, ":");
set_map(atof(strtok(NULL, "\0")));
// Read specificity
motin.getline(line, 200);
strtok(line, ":");
set_spec(atof(strtok(NULL, "\0")));
// Read sequence cutoff
motin.getline(line, 200);
strtok(line, ":");
set_seq_cutoff(atof(strtok(NULL, "\0")));
// Read expression cutoff
motin.getline(line, 200);
strtok(line, ":");
set_expr_cutoff(atof(strtok(NULL, "\0")));
// Read iteration found
motin.getline(line, 200);
strtok(line, ":");
set_iter(strtok(NULL, "\0"));
// Read dejavu
motin.getline(line, 200);
strtok(line, ":");
set_dejavu(atoi(strtok(NULL, "\0")));
}
void AudioBuffer::load(const WAVFile &_wav)
{
if(!_wav.is_open()) {
throw std::logic_error("file is not open");
}
if(_wav.format() != WAV_FORMAT_PCM && _wav.format() != WAV_FORMAT_IEEE_FLOAT) {
throw std::logic_error("unsupported data format");
}
if(_wav.channels() > 2) {
throw std::logic_error("unsupported number of channels");
}
AudioFormat format;
switch(_wav.bits()) {
case 8:
format = AUDIO_FORMAT_U8;
break;
case 16:
format = AUDIO_FORMAT_S16;
break;
case 32:
if(_wav.format() == WAV_FORMAT_IEEE_FLOAT) {
format = AUDIO_FORMAT_F32;
} else {
throw std::logic_error("unsupported data format");
}
break;
default:
throw std::logic_error("unsupported data format");
}
set_spec({format, _wav.channels(), _wav.rate()});
m_data = _wav.read();
}
CompactingPermGenGen::CompactingPermGenGen(ReservedSpace rs,
ReservedSpace shared_rs,
size_t initial_byte_size,
int level, GenRemSet* remset,
ContiguousSpace* space,
PermanentGenerationSpec* spec_) :
OneContigSpaceCardGeneration(rs, initial_byte_size, MinPermHeapExpansion,
level, remset, space) {
set_spec(spec_);
if (!UseSharedSpaces && !DumpSharedSpaces) {
spec()->disable_sharing();
}
// Break virtual space into address ranges for all spaces.
if (spec()->enable_shared_spaces()) {
shared_end = (HeapWord*)(shared_rs.base() + shared_rs.size());
misccode_end = shared_end;
misccode_bottom = misccode_end - heap_word_size(spec()->misc_code_size());
miscdata_end = misccode_bottom;
miscdata_bottom = miscdata_end - heap_word_size(spec()->misc_data_size());
readwrite_end = miscdata_bottom;
readwrite_bottom =
readwrite_end - heap_word_size(spec()->read_write_size());
readonly_end = readwrite_bottom;
readonly_bottom =
readonly_end - heap_word_size(spec()->read_only_size());
shared_bottom = readonly_bottom;
unshared_end = shared_bottom;
assert((char*)shared_bottom == shared_rs.base(), "shared space mismatch");
} else {
shared_end = (HeapWord*)(rs.base() + rs.size());
misccode_end = shared_end;
misccode_bottom = shared_end;
miscdata_end = shared_end;
miscdata_bottom = shared_end;
readwrite_end = shared_end;
readwrite_bottom = shared_end;
readonly_end = shared_end;
readonly_bottom = shared_end;
shared_bottom = shared_end;
unshared_end = shared_bottom;
}
unshared_bottom = (HeapWord*) rs.base();
// Verify shared and unshared spaces adjacent.
assert((char*)shared_bottom == rs.base()+rs.size(), "shared space mismatch");
assert(unshared_end > unshared_bottom, "shared space mismatch");
// Split reserved memory into pieces.
ReservedSpace ro_rs = shared_rs.first_part(spec()->read_only_size(),
UseSharedSpaces);
ReservedSpace tmp_rs1 = shared_rs.last_part(spec()->read_only_size());
ReservedSpace rw_rs = tmp_rs1.first_part(spec()->read_write_size(),
UseSharedSpaces);
ReservedSpace tmp_rs2 = tmp_rs1.last_part(spec()->read_write_size());
ReservedSpace md_rs = tmp_rs2.first_part(spec()->misc_data_size(),
UseSharedSpaces);
ReservedSpace mc_rs = tmp_rs2.last_part(spec()->misc_data_size());
_shared_space_size = spec()->read_only_size()
+ spec()->read_write_size()
+ spec()->misc_data_size()
+ spec()->misc_code_size();
// Allocate the unshared (default) space.
_the_space = new ContigPermSpace(_bts,
MemRegion(unshared_bottom, heap_word_size(initial_byte_size)));
if (_the_space == NULL)
vm_exit_during_initialization("Could not allocate an unshared"
" CompactingPermGen Space");
// Allocate shared spaces
if (spec()->enable_shared_spaces()) {
// If mapping a shared file, the space is not committed, don't
// mangle.
NOT_PRODUCT(bool old_ZapUnusedHeapArea = ZapUnusedHeapArea;)
AudioBuffer::AudioBuffer(const AudioSpec &_spec)
{
set_spec(_spec);
}
AudioBuffer::AudioBuffer()
{
/* sensible defaults */
set_spec({AUDIO_FORMAT_S16, 1, 44100});
}