string Namespace::getData() { string data = "{\"docs\":["; DiskLoc nextExtentLoc = firstExtentLoc; while (!nextExtentLoc.isNull()) { Extent* extent = db->getExtent(nextExtentLoc); int nextRecordOffset = extent->firstRecord; while (nextRecordOffset != -1) { Record* record = extent->getRecord(nextRecordOffset); //LOGI(record->data); data.append(record->data); nextRecordOffset = record->nextRecLoc; if (nextRecordOffset != -1) data.append(","); } nextExtentLoc = extent->nextExtent; } data.append("]}"); return data; }
void BSplineSelection::getExtent (float& l, float& b, float& cx, float& cy, float& tol, Graphic* gs) { Extent e; if (extentCached()) { getCachedExtent(e.left, e.bottom, e.cx, e.cy, e.tol); } else { FullGraphic gstmp; concatGSGraphic(ifillbspline, this, gs, &gstmp); getExtentGraphic( ifillbspline, e.left, e.bottom, e.cx, e.cy, e.tol, &gstmp ); Extent te; concatGSGraphic(bspline, this, gs, &gstmp); getExtentGraphic( bspline, te.left, te.bottom, te.cx, te.cy, te.tol, &gstmp ); e.Merge(te); cacheExtent(e.left, e.bottom, e.cx, e.cy, e.tol); } float right = 2*e.cx - e.left; float top = 2*e.cy - e.bottom; float dummy = 0; transformRect(e.left, e.bottom, right, top, l, b, dummy, dummy, gs); transform(e.cx, e.cy, cx, cy, gs); tol = MergeArrowHeadTol(e.tol, gs); }
void PolyGraphic::getextent_gs ( Coord& l, Coord& b, Coord& cx, Coord& cy, float& tol, Graphic31* gs ) { Extent e; l = b = cx = cy = tol = 0.0; Graphic31 gstemp; Transformer ttemp; Extent te; gstemp.transformer(&ttemp); GlyphIndex count = _body->count(); for (GlyphIndex i = 0; i < count; i++) { Graphic31* gr = (Graphic31*) _body->component(i); concatgs_(gr, gr, gs, &gstemp); concatXform_(gr, nil, gr->transformer(), &ttemp); getextent_(gr, te._left, te._bottom, te._cx, te._cy, te._tol, &gstemp); e.Merge(te); } gstemp.transformer(nil); // to avoid deleting ttemp explicitly l = e._left; b = e._bottom; cx = l+(e._cx-l)*2.0; cy = b+(e._cy-b)*2.0; tol = e._tol; Transformer* tx = gs->transformer(); if (tx != nil) { corners(l, b, cx, cy, *tx); } cx = (cx + l)/2.0; cy = (cy + b)/2.0; }
void RecordStoreV1Base::increaseStorageSize( TransactionExperiment* txn, int size, int quotaMax ) { DiskLoc eloc = _extentManager->allocateExtent( txn, _ns, isCapped(), size, quotaMax ); Extent *e = _extentManager->getExtent( eloc, false ); invariant( e ); DiskLoc emptyLoc = e->reuse(txn, _ns, isCapped() ); if ( _details->lastExtent().isNull() ) { verify( _details->firstExtent().isNull() ); _details->setFirstExtent( txn, eloc ); _details->setLastExtent( txn, eloc ); _details->setCapExtent( txn, eloc ); verify( e->xprev.isNull() ); verify( e->xnext.isNull() ); } else { verify( !_details->firstExtent().isNull() ); *txn->writing(&e->xprev) = _details->lastExtent(); *txn->writing(&_extentManager->getExtent(_details->lastExtent())->xnext) = eloc; _details->setLastExtent( txn, eloc ); } _details->setLastExtentSize( txn, e->length ); addDeletedRec(txn, emptyLoc); }
/* get a table scan cursor, but can be forward or reverse direction. order.$natural - if set, > 0 means forward (asc), < 0 backward (desc). */ shared_ptr<Cursor> findTableScan(const char *ns, const BSONObj& order, const DiskLoc &startLoc) { BSONElement el = order.getField("$natural"); // e.g., { $natural : -1 } if ( el.number() >= 0 ) return DataFileMgr::findAll(ns, startLoc); // "reverse natural order" NamespaceDetails *d = nsdetails(ns); if ( !d ) return shared_ptr<Cursor>(new BasicCursor(DiskLoc())); if ( !d->isCapped() ) { if ( !startLoc.isNull() ) return shared_ptr<Cursor>(new ReverseCursor( startLoc )); Extent *e = d->lastExtent().ext(); while ( e->lastRecord.isNull() && !e->xprev.isNull() ) { OCCASIONALLY out() << " findTableScan: extent empty, skipping ahead" << endl; e = e->getPrevExtent(); } return shared_ptr<Cursor>(new ReverseCursor( e->lastRecord )); } else { return shared_ptr<Cursor>( new ReverseCappedCursor( d, startLoc ) ); } }
Extent* MmapV1ExtentManager::getExtent( const DiskLoc& loc, bool doSanityCheck ) const { loc.assertOk(); Extent* e = reinterpret_cast<Extent*>( _getOpenFile( loc.a() )->p() + loc.getOfs() ); if ( doSanityCheck ) e->assertOk(); return e; }
DiskLoc _repairExtent( Database* db , string ns, bool forward , DiskLoc eLoc ){ LogIndentLevel lil; if ( eLoc.getOfs() <= 0 ){ error() << "invalid extent ofs: " << eLoc.getOfs() << endl; return DiskLoc(); } MongoDataFile * mdf = db->getFile( eLoc.a() ); Extent * e = mdf->debug_getExtent( eLoc ); if ( ! e->isOk() ){ warning() << "Extent not ok magic: " << e->magic << " going to try to continue" << endl; } log() << "length:" << e->length << endl; LogIndentLevel lil2; DiskLoc loc = forward ? e->firstRecord : e->lastRecord; while ( ! loc.isNull() ){ if ( loc.getOfs() <= 0 ){ error() << "offset is 0 for record which should be impossible" << endl; break; } log() << loc << endl; Record* rec = loc.rec(); log() << loc.obj() << endl; loc = forward ? rec->getNext( loc ) : rec->getPrev( loc ); } return forward ? e->xnext : e->xprev; }
void Namespace::insert(const char* str) { int count = 0; bson** bs = json_to_bson(str, count); Extent* lastExtent = getLastExtent(); int success = 0; for (int i(0); i < count; i++) { success = lastExtent->addRecord(bs[i]); while (success != 0) { db->attachExtent(this); lastExtent = getLastExtent(); success = lastExtent->addRecord(bs[i]); } free(bs[i]); } free(bs); }
Extent *Extent::create(Iff & iff) { Extent * extent = new Extent(); extent->load(iff); return extent; }
Sawyer::Optional<rose_addr_t> MemoryMap::findAny(const Extent &limits, const std::vector<uint8_t> &bytesToFind, unsigned requiredPerms, unsigned prohibitedPerms) const { if (limits.empty() || bytesToFind.empty()) return Sawyer::Nothing(); AddressInterval interval = AddressInterval::hull(limits.first(), limits.last()); return findAny(interval, bytesToFind, requiredPerms, prohibitedPerms); }
void NamespaceDetails::dumpExtents() { cout << "dumpExtents:" << endl; for ( DiskLoc i = _firstExtent; !i.isNull(); i = i.ext()->xnext ) { Extent *e = i.ext(); stringstream ss; e->dump(ss); cout << ss.str() << endl; } }
Extent* DummyExtentManager::getExtent( const DiskLoc& loc, bool doSanityCheck ) const { invariant( !loc.isNull() ); invariant( static_cast<size_t>( loc.a() ) < _extents.size() ); invariant( loc.getOfs() == 0 ); Extent* ext = reinterpret_cast<Extent*>( _extents[loc.a()].data ); if (doSanityCheck) ext->assertOk(); return ext; }
char* Namespace::getNextRecordData(int &recordSize) { Record *rec; if (extentCursor.isNull()) // the first time after connection the extent cursor will be null { extentCursor = firstExtentLoc; // so, get the first extent of the colection if (_DEBUG) LOGI("getting first extent"); } if (extentCursor.isNull()) // if first extent is null, then no extents exist return NULL; // no extents Extent* extent = db->getExtent(extentCursor); if (recordCursor == -1) // the first time the record cursor will be null as well { recordCursor = extent->firstRecord; // get the first record of the extent if (recordCursor == -1) // if first record is null, then no records exist return NULL; // no records rec = extent->getRecord(recordCursor); } else // else, the cursor shows the previous record, should take the next one and return its data { rec = extent->getRecord(recordCursor); if (rec->nextRecLoc == -1) // if its next record is null, then go to next extent { if (extent->nextExtent.isNull()) // if the next extent is null, then no more extents { return NULL; // no more records } else // proceed with the next extent { extentCursor = extent->nextExtent; recordCursor = -1; return getNextRecordData(recordSize); } } else { recordCursor = rec->nextRecLoc; // next record exists, so put the cursor on it if (_DEBUG) LOGI("getting next record"); rec = extent->getRecord(recordCursor); } } int bsonSize = 0; bson_little_endian32( &bsonSize, rec->data); char *val = (char*) malloc((bsonSize + 128) * sizeof(char)); int cur = 0; return bson_to_json(val, rec->data, 0, true, 0, recordSize, cur); }
virtual void firstExtent(const Extent &e) { series.setType(e.getTypePtr()); const ExtentType::Ptr extent_type(e.getTypePtr()); fields.reserve(extent_type->getNFields()); for (uint32_t i = 0; i < extent_type->getNFields(); ++i) { string field_name(extent_type->getFieldName(i)); fields.push_back(GeneralField::make(series, field_name)); into.columns.push_back(TableColumn(field_name, extent_type->getFieldTypeStr(field_name))); } into.__isset.columns = true; }
void mandelbrot_cpu_seq(Extent ext, int* dest, const int max_iter, Rectangle mi) { for (int y = 0; y < ext.get_height(); y++) { for (int x = 0; x < ext.get_width(); x++) { const int i = ext.checked_index(x, y); const float x0 = scale(x, ext.get_width(), mi.x0, mi.x1); const float y0 = scale(y, ext.get_height(), mi.y0, mi.y1); dest[i] = mandelbrot(x0, y0, max_iter); } } }
Record* Namespace::getNextRecord() { Record *rec; if (extentCursor.isNull()) // the first time after connection the extent cursor will be null { extentCursor = firstExtentLoc; // so, get the first extent of the colection if (_DEBUG) LOGI("getting first extent"); } if (extentCursor.isNull()) // if first extent is null, then no extents exist return NULL; // no extents Extent* extent = db->getExtent(extentCursor); if (recordCursor == -1) // the first time the record cursor will be null as well { recordCursor = extent->firstRecord; // get the first record of the extent if (recordCursor == -1) // if first record is null, then no records exist return NULL; // no records rec = extent->getRecord(recordCursor); } else // else, the cursor shows the previous record, should take the next one and return its data { rec = extent->getRecord(recordCursor); if (rec->nextRecLoc == -1) // if its next record is null, then go to next extent { if (extent->nextExtent.isNull()) // if the next extent is null, then no more extents { return NULL; // no more records } else // proceed with the next extent { extentCursor = extent->nextExtent; recordCursor = -1; return getNextRecord(); } } else { recordCursor = rec->nextRecLoc; // next record exists, so put the cursor on it if (_DEBUG) LOGI("getting next record"); rec = extent->getRecord(recordCursor); } } return rec; }
//-------------------------------------------------------------------------------------------------------- void CFuncNavBlocker::UpdateBlocked() { NavAreaCollector collector( true ); Extent extent; extent.Init( this ); TheNavMesh->ForAllAreasOverlappingExtent( collector, extent ); for ( int i=0; i<collector.m_area.Count(); ++i ) { CNavArea *area = collector.m_area[i]; area->UpdateBlocked( true ); } }
char* Namespace::getNextBatch(int &count) { if (_DEBUG) LOGI("get next batch"); int batchSize = 0; int sizes[count]; int jsonSize = 0; char *records[count]; //= (char**)malloc(count*sizeof(char*)); int lastRetrievedRecord = -1, recordSize, skip = 0; int i = 0; Extent *extent = getFirstExtent(); while (extent != NULL) { lastRetrievedRecord = -1; Record *record = extent->getFirstRecord(); while (record != NULL && i < count) { recordSize = 0; int bsonSize = 0; bson_little_endian32( &bsonSize, record->data); //FORCE_LOG_INT("bsonSize: ", bsonSize); char *val = (char*) malloc((bsonSize + 100) * sizeof(char)); int cur = 0; val = bson_to_json(val, record->data, 0, true, bsonSize, recordSize, cur); records[i] = val; batchSize += recordSize; sizes[i] = recordSize; jsonSize += recordSize; record = extent->getRecord(record->nextRecLoc); i++; } extent = db->getExtent(extent->nextExtent); } count = i; FORCE_LOG_INT("count: ", i); return serializeJSON(records, jsonSize, count, sizes); }
void firstExtent(const Extent &b_e) { ExtentSeries a_series; a_series.setExtent(a_input.getSharedExtent()); b_series.setType(b_e.getTypePtr()); if (a_series.getSharedExtent() == NULL) { requestError("a_table is empty?"); } // Three possible sources for values in the output: // // 1) the a value fields, so from the hash-map // 2a) the b fields, as one of the a eq fields. // 2b) the b fields, as one of the b values or eq fields // // We do not try to optimize the extraction and just create a new general field for each // extraction so if the hash-map has duplicate columns, there will be duplicate fields. vector<GeneralField::Ptr> a_eq_fields; HashUnique<string> known_a_eq_fields; BOOST_FOREACH(const CMap::value_type &vt, eq_columns) { SINVARIANT(a_series.getTypePtr()->getFieldType(vt.first) == b_series.getTypePtr()->getFieldType(vt.second)); a_eq_fields.push_back(GeneralField::make(a_series, vt.first)); b_eq_fields.push_back(GeneralField::make(b_series, vt.second)); known_a_eq_fields.add(vt.first); }
void set(Extent &e, uint8_t *row_pos, T val) { DEBUG_SINVARIANT(&e != NULL); uint8_t *byte_pos = row_pos + offset; DEBUG_SINVARIANT(e.insideExtentFixed(byte_pos)); *reinterpret_cast<T *>(byte_pos) = val; setNull(e, row_pos, false); }
/** add a record to the end of the linked list chain within this extent. require: you must have already declared write intent for the record header. */ void addRecordToRecListInExtent(Record *r, DiskLoc loc) { dassert( loc.rec() == r ); Extent *e = r->myExtent(loc); if ( e->lastRecord.isNull() ) { Extent::FL *fl = getDur().writing(e->fl()); fl->firstRecord = fl->lastRecord = loc; r->prevOfs() = r->nextOfs() = DiskLoc::NullOfs; } else { Record *oldlast = e->lastRecord.rec(); r->prevOfs() = e->lastRecord.getOfs(); r->nextOfs() = DiskLoc::NullOfs; getDur().writingInt(oldlast->nextOfs()) = loc.getOfs(); getDur().writingDiskLoc(e->lastRecord) = loc; } }
virtual void firstExtent(const Extent &e) { skip_after_count.resize(getMaxUnifiedId()+1); skip_after_skip.resize(getMaxUnifiedId() +1); const ExtentType::Ptr type = e.getTypePtr(); if (type->versionCompatible(0,0) || type->versionCompatible(1,0)) { packet_at.setFieldName("packet-at"); is_request.setFieldName("is-request"); op_id.setFieldName("op-id"); nfs_version.setFieldName("nfs-version"); transaction_id.setFieldName("transaction-id"); payload_length.setFieldName("payload-length"); record_id.setFieldName("record-id"); } else if (type->versionCompatible(2,0)) { packet_at.setFieldName("packet_at"); is_request.setFieldName("is_request"); op_id.setFieldName("op_id"); nfs_version.setFieldName("nfs_version"); transaction_id.setFieldName("transaction_id"); payload_length.setFieldName("payload_length"); record_id.setFieldName("record_id"); } else { FATAL_ERROR(format("can only handle v[0,1,2].*; not %d.%d") % type->majorVersion() % type->minorVersion()); } }
shared_ptr<Cursor> DataFileMgr::findAll(const StringData& ns, const DiskLoc &startLoc) { NamespaceDetails * d = nsdetails( ns ); if ( ! d ) return shared_ptr<Cursor>(new BasicCursor(DiskLoc())); DiskLoc loc = d->firstExtent(); if ( loc.isNull() ) return shared_ptr<Cursor>(new BasicCursor(DiskLoc())); Extent *e = getExtent(loc); DEBUGGING { out() << "listing extents for " << ns << endl; DiskLoc tmp = loc; set<DiskLoc> extents; while ( 1 ) { Extent *f = getExtent(tmp); out() << "extent: " << tmp.toString() << endl; extents.insert(tmp); tmp = f->xnext; if ( tmp.isNull() ) break; f = f->getNextExtent(); } out() << endl; d->dumpDeleted(&extents); } if ( d->isCapped() ) return shared_ptr<Cursor>( ForwardCappedCursor::make( d , startLoc ) ); if ( !startLoc.isNull() ) return shared_ptr<Cursor>(new BasicCursor( startLoc )); while ( e->firstRecord.isNull() && !e->xnext.isNull() ) { /* todo: if extent is empty, free it for reuse elsewhere. that is a bit complicated have to clean up the freelists. */ RARELY out() << "info DFM::findAll(): extent " << loc.toString() << " was empty, skipping ahead. ns:" << ns << endl; // find a nonempty extent // it might be nice to free the whole extent here! but have to clean up free recs then. e = e->getNextExtent(); } return shared_ptr<Cursor>(new BasicCursor( e->firstRecord )); }
/* special version of insert for transaction logging -- streamlined a bit. assumes ns is capped and no indexes */ Record* DataFileMgr::fast_oplog_insert(NamespaceDetails *d, const char *ns, int len) { verify( d ); RARELY verify( d == nsdetails(ns) ); DEV verify( d == nsdetails(ns) ); massert( 16509, str::stream() << "fast_oplog_insert requires a capped collection " << " but " << ns << " is not capped", d->isCapped() ); //record timing on oplog inserts boost::optional<TimerHolder> insertTimer; //skip non-oplog collections if (NamespaceString::oplog(ns)) { insertTimer = boost::in_place(&oplogInsertStats); oplogInsertBytesStats.increment(len); //record len of inserted records for oplog } int lenWHdr = len + Record::HeaderSize; DiskLoc loc = d->alloc(ns, lenWHdr); verify( !loc.isNull() ); Record *r = loc.rec(); verify( r->lengthWithHeaders() >= lenWHdr ); Extent *e = r->myExtent(loc); if ( e->lastRecord.isNull() ) { Extent::FL *fl = getDur().writing( e->fl() ); fl->firstRecord = fl->lastRecord = loc; Record::NP *np = getDur().writing(r->np()); np->nextOfs = np->prevOfs = DiskLoc::NullOfs; } else { Record *oldlast = e->lastRecord.rec(); Record::NP *np = getDur().writing(r->np()); np->prevOfs = e->lastRecord.getOfs(); np->nextOfs = DiskLoc::NullOfs; getDur().writingInt( oldlast->nextOfs() ) = loc.getOfs(); e->lastRecord.writing() = loc; } d->incrementStats( r->netLength(), 1 ); return r; }
void Picture::getExtent ( float& l, float& b, float& cx, float& cy, float& tol, Graphic* gs ) { Extent e; float right, top, dummy1, dummy2; if (extentCached()) { getCachedExtent(e._left, e._bottom, e._cx, e._cy, e._tol); } else { if (IsEmpty()) { l = b = cx = cy = tol = 0.0; return; } else { Iterator i; FullGraphic gstemp; Transformer ttemp; Extent te; gstemp.SetTransformer(&ttemp); First(i); Graphic* gr = GetGraphic(i); concatGSGraphic(gr, gr, gs, &gstemp); concatTransformerGraphic(gr, nil, gr->GetTransformer(), &ttemp); getExtentGraphic(gr, e._left,e._bottom,e._cx,e._cy,e._tol,&gstemp); for (Next(i); !Done(i); Next(i)) { gr = GetGraphic(i); concatGSGraphic(gr, gr, gs, &gstemp); concatTransformerGraphic(gr,nil, gr->GetTransformer(), &ttemp); getExtentGraphic( gr, te._left, te._bottom, te._cx, te._cy, te._tol, &gstemp ); e.Merge(te); } cacheExtent(e._left, e._bottom, e._cx, e._cy, e._tol); gstemp.SetTransformer(nil); // to avoid deleting ttemp explicitly } } right = 2*e._cx - e._left; top = 2*e._cy - e._bottom; transformRect(e._left, e._bottom, right, top, l, b, dummy1, dummy2, gs); transform(e._cx, e._cy, cx, cy, gs); tol = e._tol; }
/** Write just the specified regions back to the file */ void SgAsmGenericSection::unparse(std::ostream &f, const ExtentMap &map) const { for (ExtentMap::const_iterator i=map.begin(); i!=map.end(); ++i) { Extent e = i->first; assert(e.first()+e.size() <= get_size()); const unsigned char *extent_data; if (e.first() >= p_data.size()) { extent_data = NULL; } else if (e.first() + e.size() > p_data.size()) { extent_data = &p_data[e.first()]; } else { extent_data = &p_data[e.first()]; } if (extent_data) write(f, e.first(), e.size(), extent_data); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- Vector RandomNavAreaPositionWithin( const Vector &mins, const Vector &maxs, float minimumarea, int maxtries ) { if( maxtries < 0 ) maxtries = 1; Vector random; CNavArea *pArea = NULL; Extent extent; for( int i = 0; i < maxtries; i++ ) { random.Init( mins.x + ((float)rand() / RAND_MAX) * (maxs.x - mins.x), mins.y + ((float)rand() / RAND_MAX) * (maxs.y - mins.y), maxs.z ); pArea = TheNavMesh->GetNearestNavArea( random, false, 10000.0f, false, false ); if( pArea ) { pArea->GetExtent( &extent ); if( extent.Area() >= minimumarea ) break; } // Reset pArea = NULL; } if( !pArea ) { if( g_pynavmesh_debug.GetBool() ) DevMsg("RandomNavAreaPosition: No area found within Mins: %f %f %f, Maxs: %f %f %f, Random: %f %f %f\n", mins.x, mins.y, mins.z, maxs.x, maxs.y, maxs.z, random.x, random.y, random.z); return vec3_origin; } Vector vRandomPoint = pArea->GetRandomPoint(); vRandomPoint.z += 32.0f; if( g_pynavmesh_debug.GetBool() ) DevMsg("RandomNavAreaPosition: Found position %f %f %f\n", vRandomPoint.x, vRandomPoint.y, vRandomPoint.z); return vRandomPoint; }
//-------------------------------------------------------------------------------------------------------- void CFuncNavBlocker::BlockNav( void ) { if ( m_blockedTeamNumber == TEAM_ANY ) { for ( int i=0; i<MAX_NAV_TEAMS; ++i ) { m_isBlockingNav[ i ] = true; } } else { int teamNumber = m_blockedTeamNumber % MAX_NAV_TEAMS; m_isBlockingNav[ teamNumber ] = true; } Extent extent; extent.Init( this ); TheNavMesh->ForAllAreasOverlappingExtent( *this, extent ); }
//-------------------------------------------------------------------------------------------------------- // Reevaluate all func_nav_cost entities and update the nav decoration accordingly. // This is required to handle overlapping func_nav_cost entities. void CFuncNavCost::UpdateAllNavCostDecoration( void ) { int i, j; // first, clear all avoid decoration from the mesh for( i=0; i<TheNavAreas.Count(); ++i ) { TheNavAreas[i]->ClearAllNavCostEntities(); } // now, mark all areas with active cost entities overlapping them for( i=0; i<gm_masterCostVector.Count(); ++i ) { CFuncNavCost *cost = gm_masterCostVector[i]; if ( !cost || !cost->IsEnabled() ) { continue; } Extent extent; extent.Init( cost ); CUtlVector< CNavArea * > overlapVector; TheNavMesh->CollectAreasOverlappingExtent( extent, &overlapVector ); Ray_t ray; trace_t tr; ICollideable *pCollide = cost->CollisionProp(); for( j=0; j<overlapVector.Count(); ++j ) { ray.Init( overlapVector[j]->GetCenter(), overlapVector[j]->GetCenter() ); enginetrace->ClipRayToCollideable( ray, MASK_ALL, pCollide, &tr ); if ( tr.startsolid ) { overlapVector[j]->AddFuncNavCostEntity( cost ); } } } }
bool val(const Extent &e, uint8_t *row_pos) const { DEBUG_SINVARIANT(&e != NULL); uint8_t *byte_pos = row_pos + offset; DEBUG_SINVARIANT(e.insideExtentFixed(byte_pos)); if (nullable && isNull(e, row_pos)) { return default_value; } else { return *byte_pos & bit_mask ? true : false; } }