void toNormalizedNEXUS(ifstream & inf, ostream *os)
{
NxsTaxaBlock taxa;
NxsTreesBlock trees(&taxa);
NxsAssumptionsBlock assumptions(&taxa);
NxsCharactersBlock character(&taxa, &assumptions);
NxsDataBlock data(&taxa, &assumptions);
NxsDistancesBlock distances(&taxa);
NxsUnalignedBlock unaligned(&taxa, &assumptions);
NormalizingReader nexus(os);
nexus.Add(&taxa);
nexus.Add(&trees);
nexus.Add(&assumptions);
nexus.Add(&character);
nexus.Add(&data);
nexus.Add(&distances);
nexus.Add(&unaligned);
if (os)
{
*os << "#NEXUS\n";
}
NormalizingToken token(inf, os);
nexus.Execute(token);
}
bool thread_cache::fetch_page(string const &key,string &out,bool gzip)
{
rwlock_rdlock lock(access_lock);
string *r=get(key,NULL);
if(!r) return false;
size_t size=r->size();
size_t s;
char const *ptr=r->c_str();
if(size<sizeof(size_t) || (s=unaligned((size_t const *)ptr))>size-sizeof(size_t))
return false;
if(!gzip){
out.assign(ptr+sizeof(size_t),s);
}
else {
ptr+=s+sizeof(size_t);
size-=s+sizeof(size_t);
if(size<sizeof(size_t) || (s=unaligned((size_t const *)ptr))!=size-sizeof(size_t))
return false;
out.assign(ptr+sizeof(size_t),s);
}
return true;
}
inline
void *
AbstractionLayer::Allocator::internalRePalloc(void *inPtr, size_t inSize) const {
#if MAXIMUM_ALIGNOF >= 16
return repalloc(inPtr, inSize);
#else
if (inSize > std::numeric_limits<size_t>::max() - 16) {
pfree(unaligned(inPtr));
return NULL;
}
/* Precondition: inSize <= std::numeric_limits<size_t>::max() - 16 */
const size_t size = inSize + 16;
void *raw = repalloc(unaligned(inPtr), size);
if (ZM == dbal::DoZero) {
std::fill(
static_cast<char*>(raw),
static_cast<char*>(raw) + inSize, 0);
}
return makeAligned(raw);
#endif
}
inline
void
AbstractionLayer::Allocator::free(void *inPtr) const {
if (inPtr == NULL)
return;
/*
* See allocate(const size_t, const std::nothrow_t&) why we disable
* processing of interrupts.
*/
HOLD_INTERRUPTS();
PG_TRY(); {
pfree(unaligned(inPtr));
} PG_CATCH(); {
FlushErrorState();
} PG_END_TRY();
RESUME_INTERRUPTS();
}
