void test::TestComponentPool() { auto components = new stoked::ComponentPool<ComponentA>(4); auto c1 = components->Get(); auto c2 = components->Get(); auto c3 = components->Get(); auto c4 = components->Get(); assert(c1 != nullptr); assert(c2 != nullptr); assert(c3 != nullptr); assert(c4 != nullptr); assert(c1->GetID() < components->GetCapacity()); assert(c2->GetID() < components->GetCapacity()); assert(c3->GetID() < components->GetCapacity()); assert(c4->GetID() < components->GetCapacity()); // Currently, when "Get" is called, the component is not "free", in the sense that it is assumed that it is // attached to an entity. This is actually pretty confusing. assert(!c1->IsFree()); assert(!c2->IsFree()); assert(!c3->IsFree()); assert(!c4->IsFree()); PASSED(); }
void test::TestEntityPool() { auto entities = new stoked::EntityPool(4); auto e1 = entities->Create(); auto e2 = entities->Create(); auto e3 = entities->Create(); auto e4 = entities->Create(); assert(e1 != nullptr); assert(e2 != nullptr); assert(e3 != nullptr); assert(e4 != nullptr); assert(e1->GetID() < entities->GetCapacity()); assert(e2->GetID() < entities->GetCapacity()); assert(e3->GetID() < entities->GetCapacity()); assert(e4->GetID() < entities->GetCapacity()); assert(entities->Empty() && !entities->Available()); entities->FreeAll(); assert(!entities->Empty() && entities->Available()); e1 = entities->Create(); bool freeResult = entities->Free(e1); assert(freeResult == true); delete entities; PASSED(); }
bool TBListBackend::GrowIfNeeded() { int capacity = GetCapacity(); if (GetNumItems() == capacity) return Reserve(CLAMP(4, capacity * 2, 1024)); return true; }
CPUBuffer::CPUBuffer(uint8_t elementSize, uint32_t capacity) : TBase(elementSize, capacity) { uint32_t memorySize = my::NextPowOf2(GetCapacity() * GetElementSize()); m_memory = SharedBufferManager::instance().reserveSharedBuffer(memorySize); m_memoryCursor = NonConstData(); }
int Append(const T& stValue) { if (m_iSize >= GetCapacity()) { return -1; } m_astData[m_iSize++] = stValue; }
Object2D* Bullet2DFactory::GetObject() { for(Bullet2D* bullet = begin; bullet != end; ++bullet) { if(!bullet->active) { return bullet; } } IncreaseSize(); return begin + GetCapacity(); }
bool TBListBackend::Reserve(int new_capacity) { assert(new_capacity > 0); if (new_capacity > GetCapacity()) { int num = GetNumItems(); if (char *new_data = (char *) realloc(m_data, sizeof(TBLIST_DATA) + sizeof(void *) * (new_capacity))) { m_data = (TBLIST_DATA *) new_data; m_data->num = num; m_data->capacity = new_capacity; m_data->list = (void**) (new_data + sizeof(TBLIST_DATA)); return true; } return false; } return true; }
void Bullet2DFactory::IncreaseSize() { const unsigned oldCapacity = GetCapacity(); const unsigned newCapacity = oldCapacity + sizeIncrease; Bullet2D* buffer = new Bullet2D[newCapacity]; if(begin) { //transfer the previous bullet data to the new memory memcpy(buffer, begin, oldCapacity); delete [] begin; begin = NULL; end = NULL; } begin = buffer; end = buffer + newCapacity; }
// Load //------------------------------------------------------------------------------ bool Dependencies::Load( NodeGraph & nodeGraph, IOStream & stream ) { uint32_t numDeps; if ( stream.Read( numDeps ) == false ) { return false; } if ( GetCapacity() < GetSize() + numDeps ) { SetCapacity( GetSize() + numDeps ); } for ( uint32_t i=0; i<numDeps; ++i ) { // Read node index uint32_t index( INVALID_NODE_INDEX ); if ( stream.Read( index ) == false ) { return false; } // Convert to Node * Node * node = nodeGraph.GetNodeByIndex( index ); ASSERT( node ); // Read weak flag bool isWeak( false ); if ( stream.Read( isWeak ) == false ) { return false; } // Recombine dependency info Append( Dependency( node, isWeak ) ); } return true; }
/// Zwraca true, jeœli bufor jest pe³ny bool IsFull() { return GetSize() == GetCapacity(); }
void csStringBase::SetCapacity (size_t NewSize) { if (NewSize + 1 > GetCapacity() + 1) // GLOBAL NOTE *1* SetCapacityInternal (NewSize, false); }
void csStringBase::ExpandIfNeeded(size_t NewSize) { if (GetData() == 0 || NewSize + 1 > GetCapacity() + 1) // GLOBAL NOTE *1* SetCapacityInternal (NewSize, true); }
MockCSIPlugin::MockCSIPlugin() { EXPECT_CALL(*this, GetPluginInfo(_, _, _)) .WillRepeatedly(Return(Status::OK)); // Enable all plugin capabilities by default for testing with the test CSI // plugin in forwarding mode. EXPECT_CALL(*this, GetPluginCapabilities(_, _, _)) .WillRepeatedly(Invoke([]( ServerContext* context, const csi::v0::GetPluginCapabilitiesRequest* request, csi::v0::GetPluginCapabilitiesResponse* response) { response->add_capabilities()->mutable_service()->set_type( csi::v0::PluginCapability::Service::CONTROLLER_SERVICE); return Status::OK; })); EXPECT_CALL(*this, Probe(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, CreateVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, DeleteVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, ControllerPublishVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, ControllerUnpublishVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, ValidateVolumeCapabilities(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, ListVolumes(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, GetCapacity(_, _, _)) .WillRepeatedly(Return(Status::OK)); // Enable all controller capabilities by default for testing with the test CSI // plugin in forwarding mode. EXPECT_CALL(*this, ControllerGetCapabilities(_, _, _)) .WillRepeatedly(Invoke([]( ServerContext* context, const csi::v0::ControllerGetCapabilitiesRequest* request, csi::v0::ControllerGetCapabilitiesResponse* response) { response->add_capabilities()->mutable_rpc()->set_type( csi::v0::ControllerServiceCapability::RPC::CREATE_DELETE_VOLUME); response->add_capabilities()->mutable_rpc()->set_type( csi::v0::ControllerServiceCapability::RPC::PUBLISH_UNPUBLISH_VOLUME); response->add_capabilities()->mutable_rpc()->set_type( csi::v0::ControllerServiceCapability::RPC::GET_CAPACITY); response->add_capabilities()->mutable_rpc()->set_type( csi::v0::ControllerServiceCapability::RPC::LIST_VOLUMES); return Status::OK; })); EXPECT_CALL(*this, NodeStageVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, NodeUnstageVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, NodePublishVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, NodeUnpublishVolume(_, _, _)) .WillRepeatedly(Return(Status::OK)); EXPECT_CALL(*this, NodeGetId(_, _, _)) .WillRepeatedly(Return(Status::OK)); // Enable all node capabilities by default for testing with the test CSI // plugin in forwarding mode. EXPECT_CALL(*this, NodeGetCapabilities(_, _, _)) .WillRepeatedly(Invoke([]( ServerContext* context, const csi::v0::NodeGetCapabilitiesRequest* request, csi::v0::NodeGetCapabilitiesResponse* response) { response->add_capabilities()->mutable_rpc()->set_type( csi::v0::NodeServiceCapability::RPC::STAGE_UNSTAGE_VOLUME); return Status::OK; })); }
int32 UFlareCargoBay::GetFreeCargoSpace() const { return GetCapacity() - GetUsedCargoSpace(); }
T& operator[](int i) { assert(i >= 0 && i < GetCapacity() && i < GetSize()); return m_astData[i]; }