// ----------------------------------------------------------------------------- // ActivateZoom // ----------------------------------------------------------------------------- EXPORT_C void CGlxHdmiController::ActivateZoom(TBool aAutoZoomOut) { TRACER("CGlxHdmiController::ActivateZoom()"); if (iSurfaceUpdater) { iSurfaceUpdater->ActivateZoom(aAutoZoomOut); } }
// ----------------------------------------------------------------------------- // NewL // ----------------------------------------------------------------------------- // CGlxFetchErrorArray* CGlxFetchErrorArray::NewL(const CGlxFetchErrorArray* aErrorArray) { TRACER("CGlxFetchErrorArray::NewL"); CGlxFetchErrorArray* self = CGlxFetchErrorArray::NewLC(aErrorArray); CleanupStack::Pop(self); return self; }
// ----------------------------------------------------------------------------- // NewLC // ----------------------------------------------------------------------------- EXPORT_C CGlxHdmiController* CGlxHdmiController::NewL(TRect aRect) { TRACER("CGlxHdmiController* CGlxHdmiController::NewL()"); CGlxHdmiController* self = new (ELeave) CGlxHdmiController(aRect); CleanupStack::PushL(self); self->ConstructL(); CleanupStack::Pop(self); return self; }
// ----------------------------------------------------------------------------- // ConstructL // ----------------------------------------------------------------------------- // void CGlxGarbageCollector::ConstructL() { TRACER("CGlxGarbageCollector::ConstructL"); // Create callback loop in the lowest priority, so that the garbage // collection does not slow down the application iPeriodic = CPeriodic::NewL( CActive::EPriorityIdle ); iAttributesInUse.ReserveL(KMaxAttributesInUse); }
// ----------------------------------------------------------------------------- // Clean up cache that is currently under cleanup // return number of items yet to scan during this idle callback // ----------------------------------------------------------------------------- // TInt CGlxGarbageCollector::CleanupCache( CGlxCache& aCache, TInt aRemainingScanCount ) { TRACER( "CGlxGarbageCollector::CleanupCache" ); // set the maximum number of items to scan during this call TInt remainingScanCount = aRemainingScanCount; // don't store cache.Count() locally, as the count changes during the loop while ( iScanningPosition.iNextMediaIndexToCleanup < aCache.Count() && remainingScanCount > 0 && ( aCache.IdSpaceId() != KGlxIdSpaceIdRoot ) ) { CGlxMedia& media = aCache.Media( iScanningPosition.iNextMediaIndexToCleanup ); if ( media.UserCount() > 0 ) { // the media object still has users. Check if any attributes // it has can be deleted. TRAPD( err, CleanupMediaL( aCache, media ) ); // skip the media object if cleanup failed. This allows cleanup to // continue also when has no free memory. Skip also if there // are still attributes in use. if ( ( media.Count() == 0 && !err ) || ( err > 0 ) ) { // the media object has no more attributes. It can be deleted. // don't increment iNextMediaIndexToCleanup since the index // of the next item will be decreased by one due to removal aCache.Delete( iScanningPosition.iNextMediaIndexToCleanup ); GLX_LOG_INFO1( "CGlxGarbageCollector - Deleted Media Id=%d since no attributes left", media.Id().Value()); } else if( err < 0 ) { // scan next item iScanningPosition.iNextMediaIndexToCleanup++; } else { // scan next item iScanningPosition.iNextMediaIndexToCleanup++; } } else { // the media object has no more users in present cache. It may be deleted if( !MediaInUse( media ) ) { // Bug Fix @ EDDG-7V3CJA:: Recheck other caches for UserCount aCache.Delete( iScanningPosition.iNextMediaIndexToCleanup ); GLX_LOG_INFO1( "CGlxGarbageCollector - Deleted Media Id=%d since no users left", media.Id().Value()); } } remainingScanCount--; } return remainingScanCount; }
// ----------------------------------------------------------------------------- // NewLC // ----------------------------------------------------------------------------- // CGlxFetchErrorArray* CGlxFetchErrorArray::NewLC(const CGlxFetchErrorArray* aErrorArray) { TRACER("CGlxFetchErrorArray::NewLC"); CGlxFetchErrorArray* self = new( ELeave ) CGlxFetchErrorArray(); CleanupStack::PushL( self ); self->CopyConstructL(aErrorArray); return self; }
// return true if the atom is t = t // 29/04/2002 Manchester bool Atom::isTautology () const { TRACER("Atom::isTautology"); if ( ! isEquality() ) return false; return args().head().equal(args().second()); } // Atom::isTautology
// ----------------------------------------------------------------------------- // ShiftToCloningMode // ----------------------------------------------------------------------------- EXPORT_C void CGlxHdmiController::ShiftToCloningMode() { TRACER("CGlxHdmiController::ShiftToCloningMode()"); // Shift to cloning only if HDMI is connected and surfaceupdater available. if (iSurfaceUpdater) { iSurfaceUpdater->ShiftToCloningMode(); } }
// ----------------------------------------------------------------------------- // DestroySurfaceUpdater // ----------------------------------------------------------------------------- void CGlxHdmiController::DestroySurfaceUpdater() { TRACER("CGlxHdmiController::DestroySurfaceUpdater()"); if (iSurfaceUpdater) { delete iSurfaceUpdater; iSurfaceUpdater = NULL; } }
EXPORT_C void CGlxDataSourceTask::HandleRequestComplete(TInt aError) { TRACER("void CGlxDataSourceTask::HandleRequestComplete(TInt aError)"); GLX_DEBUG2("Entering CGlxDataSourceTask::HandleRequestComplete() error %d", aError); if( !iCancelled && iResponse && iObserver ) { iObserver->HandleResponse(iResponse, iRequest, aError); iDataSource->HandleTaskComplete(this); } }
// ----------------------------------------------------------------------------- // CancelCleanup // ----------------------------------------------------------------------------- // void CGlxGarbageCollector::CancelCleanup() { TRACER("CGlxGarbageCollector::CancelCleanup"); if (iPeriodic->IsActive()) { iPeriodic->Cancel(); // Consideration of Restarting the timer is there; } }
CGlxGetRequest::CGlxGetRequest(const RArray<TGlxMediaId>& aMediaIdArray, const RArray<TMPXAttribute>& aAttributeArray, const RArray<TMPXAttribute>& aCpiAttributeArray, const TUid& aCollectionPluginUid, const TBool aDoNotNeedDataSource) : CGlxRequest(aCollectionPluginUid, aDoNotNeedDataSource), iMediaIdArray(aMediaIdArray), iAttributeArray(aAttributeArray), iCpiAttributeArray(aCpiAttributeArray) { TRACER("CGlxGetRequest::CGlxGetRequest()"); }
// ----------------------------------------------------------------------------- // DestroyContainer // ----------------------------------------------------------------------------- void CGlxHdmiController::DestroyContainer() { TRACER("CGlxHdmiController::DestroyContainer()"); if (iHdmiContainer) { GLX_LOG_INFO("CGlxHdmiController::DestroyHdmi() - deleting iHdmiContainer 1"); delete iHdmiContainer; iHdmiContainer = NULL; } }
// ----------------------------------------------------------------------------- // NewL // ----------------------------------------------------------------------------- // CGlxGarbageCollector* CGlxGarbageCollector::NewL( const RPointerArray<CGlxCache>& aCaches ) { TRACER( "CGlxGarbageCollector::NewL" ); CGlxGarbageCollector* self = new( ELeave ) CGlxGarbageCollector( aCaches ); CleanupStack::PushL( self ); self->ConstructL(); CleanupStack::Pop(self); return self; }
// ----------------------------------------------------------------------------- // Unmark all medialist items. // ----------------------------------------------------------------------------- EXPORT_C void MGlxMediaList::UnmarkAllL( MGlxMediaList& aList ) { TRACER("MGlxMediaList::UnmarkAllL"); TInt count = aList.Count(); for ( TInt i = 0; i <= count ; i++ ) { aList.SetSelectedL( i, EFalse ); } }
TBool CGlxDataSourceTask::ObserverMatch(MGlxDataSourceRequestObserver& aObserver) { TRACER("TBool CGlxDataSourceTask::ObserverMatch(MGlxDataSourceRequestObserver& aObserver)"); if(&aObserver == iObserver) { return ETrue; } else { return EFalse; } }
// true if this is t1 = t2 and a is t2 = t1 // 29/04/2002, Manchester // 28/08/2002 Torrevieja changed bool Atom::swap (Atom a) const { TRACER("Atom::swap"); if ( ! isEquality() ) return false; if ( ! a.isEquality() ) return false; return args().head().equal (a.args().second()) && a.args().head().equal(args().second()); } // Atom::swap
// 28/08/2002 Torrevieja void Atom::rectify (Substitution& subst, Var& last, VarList& freeVars) { TRACER ("Atom::rectify"); TermList ts (args()); ts.rectify (subst, last, freeVars); if (ts == args()) { // space-economic version return; } Atom a (functor(),ts); *this = a; } // Atom::rectify
// ----------------------------------------------------------------------------- // CopyConstructL // ----------------------------------------------------------------------------- // void CGlxFetchErrorArray::CopyConstructL(const CGlxFetchErrorArray* aErrorArray) { TRACER("CGlxFetchErrorArray::CopyConstructL"); if ( aErrorArray ) { TInt count = aErrorArray->iFetchErrors.Count(); for ( TInt index = 0; index < count; index++ ) { iFetchErrors.AppendL(aErrorArray->iFetchErrors[index]); } } }
// 28/08/2002 Torrevieja void Atom::apply ( const Substitution& subst ) { TRACER ("Atom::apply"); TermList ts (args()); ts.apply (subst); if (ts == args()) { // space-economic version return; } Atom a (functor(),ts); *this = a; } // Atom::apply
// ----------------------------------------------------------------------------- // destructor // ----------------------------------------------------------------------------- EXPORT_C CGlxHdmiController::~CGlxHdmiController() { TRACER("CGlxHdmiController::~CGlxHdmiController()"); DestroySurfaceUpdater(); DestroyContainer(); delete iStoredImagePath; iStoredImagePath = NULL; if (iFsBitmap) { delete iFsBitmap; iFsBitmap = NULL; } }
// ----------------------------------------------------------------------------- // Callback from periodic timer // ----------------------------------------------------------------------------- // TInt CGlxGarbageCollector::PeriodicCallbackL( TAny* aPtr ) { TRACER("CGlxGarbageCollector::PeriodicCallback"); GLX_ASSERT_DEBUG( aPtr != NULL, Panic( EGlxPanicLogicError ), "Received null pointer for garbage collector" ); // get "this" pointer static_cast< CGlxGarbageCollector* >( aPtr )->PeriodicCallbackL(); // return value ignored for periodic timers return 0; }
/** * Init_hermann_rdkafka * * Called by Ruby when the Hermann gem is loaded. * Defines the Hermann module. * Defines the Producer and Consumer classes. */ void Init_hermann_rdkafka() { VALUE lib_module, provider_module, c_consumer, c_producer; TRACER("setting up Hermann::Provider::RDKafka\n"); /* Define the module */ hermann_module = rb_define_module("Hermann"); provider_module = rb_define_module_under(hermann_module, "Provider"); lib_module = rb_define_module_under(provider_module, "RDKafka"); /* ---- Define the consumer class ---- */ c_consumer = rb_define_class_under(lib_module, "Consumer", rb_cObject); /* Allocate */ rb_define_alloc_func(c_consumer, consumer_allocate); /* Initialize */ rb_define_method(c_consumer, "initialize", consumer_initialize, 4); rb_define_method(c_consumer, "initialize_copy", consumer_init_copy, 1); /* Consumer has method 'consume' */ rb_define_method( c_consumer, "consume", consumer_consume, 1); /* ---- Define the producer class ---- */ c_producer = rb_define_class_under(lib_module, "Producer", rb_cObject); /* Allocate */ rb_define_alloc_func(c_producer, producer_allocate); /* Initialize */ rb_define_method(c_producer, "initialize", producer_initialize, 1); rb_define_method(c_producer, "initialize_copy", producer_init_copy, 1); /* Producer.push_single(msg) */ rb_define_method(c_producer, "push_single", producer_push_single, 3); /* Producer.tick */ rb_define_method(c_producer, "tick", producer_tick, 1); /* Producer.connected? */ rb_define_method(c_producer, "connected?", producer_is_connected, 0); /* Producer.errored? */ rb_define_method(c_producer, "errored?", producer_is_errored, 0); /* Producer.connect */ rb_define_method(c_producer, "connect", producer_connect, 1); /* Producer.metadata */ rb_define_method(c_producer, "metadata", producer_metadata, 2); }
void CGlxRequest::ConstructL(const CMPXFilter* aFilter) { TRACER("void CGlxRequest::ConstructL(const CMPXFilter* aFilter)"); if (aFilter) { // Take a copy of the filter as we do not own it. iFilter = CMPXFilter::NewL(*aFilter); } else { // No filter supplied, so create a default filter; iFilter = TGlxFilterFactory::CreateAlphabeticSortFilterL(); } }
// ----------------------------------------------------------------------------- // GetAttributesInUseL // ----------------------------------------------------------------------------- // void CGlxGarbageCollector::GetAttributesInUseL( const CGlxMedia& aMedia, RArray<TMPXAttribute>& aAttributes ) const { TRACER("CGlxGarbageCollector::GetAttributesInUseL"); // get needed attributes from each user of the media object // ( unlikely to have many users, so calling CGlxMedia::UserCount and // CGlxMedia::Id within the loop ) for ( TInt userIndex = 0; userIndex < aMedia.UserCount(); userIndex++ ) { aMedia.User( userIndex ).GetRequiredAttributesL( aMedia.IndexInUser( userIndex ), aAttributes ); } }
static VALUE producer_connect(VALUE self, VALUE timeout) { HermannInstanceConfig *producerConfig; rd_kafka_resp_err_t err; VALUE result = Qfalse; hermann_metadata_ctx_t md_context; Data_Get_Struct(self, HermannInstanceConfig, producerConfig); if (!producerConfig->isInitialized) { producer_init_kafka(self, producerConfig); } md_context.rk = producerConfig->rk; md_context.topic = NULL; md_context.data = NULL; md_context.timeout_ms = rb_num2int(timeout); err = producer_metadata_request(&md_context); TRACER("err: %s (%i)\n", rd_kafka_err2str(err), err); if (RD_KAFKA_RESP_ERR_NO_ERROR == err) { TRACER("brokers: %i, topics: %i\n", md_context.data->broker_cnt, md_context.data->topic_cnt); producerConfig->isConnected = 1; result = Qtrue; } else { producerConfig->isErrored = err; } if ( md_context.data ) rd_kafka_metadata_destroy(md_context.data); return result; }
EXPORT_C CGlxGetRequest* CGlxGetRequest::NewL(const RArray<TGlxMediaId>& aMediaIdArray, const RArray<TMPXAttribute>& aAttributeArray, const RArray<TMPXAttribute>& aCpiAttributeArray, const TUid& aCollectionPluginUid, CMPXFilter* aFilter, const TBool aDoNotNeedDataSource) { TRACER("CGlxGetRequest* CGlxGetRequest::NewL()"); CGlxGetRequest* task = new (ELeave) CGlxGetRequest(aMediaIdArray, aAttributeArray, aCpiAttributeArray, aCollectionPluginUid, aDoNotNeedDataSource); CleanupStack::PushL(task); task->ConstructL(aFilter); CleanupStack::Pop(task); return task; }
// return true if the atoms are r = s, s = t, and r = t (up to commutativity) // 29/04/2002 Manchester // 28/08/2002 Torrevieja, changed bool Atom::transitivity (Atom a1, Atom a2, Atom a3) { TRACER("Atom::transitivity"); if ( ! (a1.isEquality() && a2.isEquality() && a3.isEquality()) ) { return false; } // a1, a2, a3 are equalities Term l1 (a1.args().head()); Term r1 (a1.args().second()); if ( l1.equal(r1) ) { return false; } Term l2 (a2.args().head()); Term r2 (a2.args().second()); if ( l2.equal(r2) ) { return false; } Term l3 (a3.args().head()); Term r3 (a3.args().second()); if ( l3.equal(r3) ) { return false; } if ( l1.equal(l2) ) { // l1 = l2 = s return (r1.equal(l3) && r2.equal(r3)) || (r2.equal(l3) && r1.equal(r3)); } // l1 != l2 if ( l1.equal(r2) ) { // l1 = r2 = s return (r1.equal(l3) && l2.equal(r3)) || (l2.equal(l3) && r1.equal(r3)); } // if ( r1.equal(l2) ) { // r1 = l2 = s return (l1.equal(l3) && r2.equal(r3)) || (r2.equal(l3) && l1.equal(r3)); } // l1 not in {l2,r2}, r1 != l2 if ( r1.equal(r2) ) { // r1 = r2 = s return (l1.equal(l3) && l2.equal(r3)) || (l2.equal(l3) && l1.equal(r3)); } return false; } // Atom::transitivity
// ----------------------------------------------------------------------------- // Flush Count Pages // ----------------------------------------------------------------------------- // void CGlxGarbageCollector::FlushPagesL(TInt aCount) { TRACER("CGlxGarbageCollector::FlushPagesL"); TBool reachedEnd = CleanupCaches(aCount); if ( reachedEnd ) { // reset to the start of the caches iScanningPosition.iCurrentCacheIndex = 0; iScanningPosition.iNextMediaIndexToCleanup = 0; // next time the full round reaches end, the caches will be fully clean // (unless client calls Cleanup() ) iRequiresFullCleanupRound = EFalse; } }
// ----------------------------------------------------------------------------- // Delete all attributes from a media object except those specified // ----------------------------------------------------------------------------- // void CGlxGarbageCollector::DeleteOtherAttributes( CGlxCache& /*aCache*/, CGlxMedia& aMedia, const RArray<TMPXAttribute>& aAttributesToKeep ) const { TRACER("CGlxGarbageCollector::DeleteOtherAttributes"); // loop backwards so can delete attributes during the loop for ( TInt attrIndex = aMedia.Count() - 1; attrIndex >= 0; attrIndex-- ) { // delete the attribute if it is not in use if ( KErrNotFound == aAttributesToKeep.Find( aMedia.Attribute( attrIndex ), TMPXAttribute::Match ) ) { GLX_LOG_INFO( "CGlxGarbageCollector::CleanupMediaL - Deleted attribute" ); aMedia.DeleteAttribute( attrIndex ); } } }