FCL/sf/app/radio: comparison radioapp/radiouiengine/src/radiostation.cpp

equal deleted inserted replaced

-:075425b8d9a4
+:189d20c34778
 const uint DISABLE_LOCAL_AREA_COVERAGE_MASK = 0x0800;
 const int PS_NAME_CHANGE_THRESHOLD_SECONDS = 10;
+// Macros to help protect shared null and manual station instances to help debugging
+// Enabled in emulator or win32 builds by default
+#if defined __WINS__ || defined BUILD_WIN32
+#   define PROTECT_SHAREDNULL_AND_MANUALSTATION
+#endif
+#ifdef PROTECT_SHAREDNULL_AND_MANUALSTATION
+#   define ASSERT_SHARED_NULL_IS_INTACT \
+Q_ASSERT_X( mData->mPresetIndex != SharedNull, "RadioStation", "Shared null modified illegally!" );
+#   define ASSERT_MANUAL_STATION \
+Q_ASSERT_X( mData->mPresetIndex != ManualStation, "RadioStation", "Illegally modifying manual station" );
+#else
+#   define ASSERT_SHARED_NULL_IS_INTACT
+#   define ASSERT_MANUAL_STATION
+#endif // PROTECT_SHAREDNULL_AND_MANUALSTATION
 /**
 * Static shared data instance that is used by all default-constructed RadioStation instances
 */
-Q_GLOBAL_STATIC_WITH_ARGS( RadioStationPrivate, shared_null, ( RadioStation::SharedNull ) )
+static RadioStationPrivate shared_null( RadioStation::SharedNull, 0 );
 /*!
 *
 */
 QString RadioStation::parseFrequency( uint frequency )
 /*!
 *
 */
 RadioStation::RadioStation() :
-QObject( 0 )
+mData( &shared_null )
 {
-mData = shared_null();
-mData->ref.ref();
 }
 /*!
 *
 */
 RadioStation::RadioStation( const RadioStation& other ) :
-QObject( 0 )
+mData( other.mData )
+{
+}
+/*!
+*
+*/
+RadioStation::RadioStation( int presetIndex, uint frequency ) :
+mData( new RadioStationPrivate( presetIndex, frequency ) )
+{
+}
+/*!
+*
+*/
+RadioStation::~RadioStation()
+{
+}
+/*!
+*
+*/
+RadioStation& RadioStation::operator=( const RadioStation& other )
 {
 mData = other.mData;
-mData->ref.ref();
-}
-/*!
-*
-*/
-RadioStation::RadioStation( int presetIndex, uint frequency ) :
-QObject( 0 )
-{
-mData = new RadioStationPrivate( presetIndex, frequency );
-}
-/*!
-*
-*/
-RadioStation::~RadioStation()
-{
-decrementReferenceCount();
-}
-/*!
-*
-*/
-RadioStation& RadioStation::operator=( const RadioStation& other )
-{
-qAtomicAssign( mData, other.mData );
 return *this;
 }
 /*!
 *
 */
 void RadioStation::reset()
 {
-decrementReferenceCount();
+mData = &shared_null;
-mData = shared_null();
+ASSERT_SHARED_NULL_IS_INTACT
-mData->ref.ref();
 }
 /*!
 *
 */
 void RadioStation::setChangeFlags( RadioStation::Change flags )
 {
 if ( mData->mChangeFlags != flags ) {
-detach();
 mData->mChangeFlags = flags;
 }
 }
 /*!
 *
 */
 void RadioStation::setPresetIndex( int presetIndex )
 {
 if ( mData->mPresetIndex != presetIndex ) {
-detach();
+ASSERT_MANUAL_STATION
 mData->mPresetIndex = presetIndex;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged;
 }
 }
 *
 */
 void RadioStation::setFrequency( uint frequency )
 {
 if ( mData->mFrequency != frequency ) {
-detach();
 mData->mFrequency = frequency;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 * Sets the preset name
 void RadioStation::setName( const QString& name )
 {
 // Name emptiness is checked because this name setter is used by incoming RDS PS name
 // and empty names should be ignored
 if ( !name.isEmpty() && !mData->mRenamedByUser && mData->mName.compare( name ) != 0 ) {
-detach();
 mData->mName = name.trimmed();
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::NameChanged;
 // Save the time when PS name changed and if the last change was too close to the current time
 // change the PS type to dynamic if it has already been incorrectly determined to be static.
 mData->mUrl = "<a href=\"buu\">www." + mData->mName.toLower() + ".fi</a>";
 } else {
 mData->mUrl = "";
 }
 mData->mChangeFlags |= RadioStation::UrlChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 */
 void RadioStation::setGenre( const int genre )
 {
 if ( mData->mGenre != genre ) {
-detach();
 mData->mGenre = genre;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::GenreChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 */
 void RadioStation::setUrl( const QString& url )
 {
 if ( mData->mUrl.compare( url ) != 0 ) {
-detach();
 mData->mUrl = url;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::UrlChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 * Sets the PI code
 */
 bool RadioStation::setPiCode( int piCode, RadioRegion::Region region )
 {
 LOG_FORMAT( "RadioStation::setPiCode new PI: %d", piCode );
 // toggling local area coverage bit code must not be interpreted as new PI code
-if( region != RadioRegion::America )
+if ( region != RadioRegion::America ) {
-{
 piCode &= ~DISABLE_LOCAL_AREA_COVERAGE_MASK;
 }
 LOG_FORMAT( "stored PI: %d", mData->mPiCode );
 LOG_FORMAT( "call sign check done: %d", mData->mCallSignCheckDone );
 //prevent executing the below code when unnessesary
-if ( mData->mPiCode != piCode || !mData->mCallSignCheckDone )
+if ( mData->mPiCode != piCode || !mData->mCallSignCheckDone ) {
-	{
-detach();
 mData->mPiCode = piCode;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::PiCodeChanged;
 // call sign not calculated for clear channel stations
 		//TODO: Remove magic numbers
-if( ( (mData->mPiCode & 0xF000 ) >> 12 ) == 0x1 )
+if ( ( (mData->mPiCode & 0xF000 ) >> 12 ) == 0x1 ) {
-{
 LOG( "Clear channel station" );
 mData->mCallSignCheckDone = true;
-}
+} else if ( region == RadioRegion::America && mData->mName.isEmpty() && !isRenamed() ) {
-		// if America region, not PS name received and not user renamed station
-else if ( region == RadioRegion::America && mData->mName.isEmpty() && !isRenamed() )
-{
 LOG( "Calculate call sign" );
 mData->mName = piCodeToCallSign( mData->mPiCode );
 mData->mChangeFlags |= RadioStation::NameChanged;
 }
-if ( mData->mChangeFlags.testFlag( RadioStation::PsTypeChanged ) )
+if ( mData->mChangeFlags.testFlag( RadioStation::PsTypeChanged ) ) {
-		{
 LOG( "Call sign check done" );
 mData->mCallSignCheckDone = true;
 }
+ASSERT_SHARED_NULL_IS_INTACT
 return true;
 }
 return false;
 }
 *
 */
 void RadioStation::setPsType( PsType psType )
 {
 if ( mData->mPsType != psType ) {
-detach();
 mData->mPsType = psType;
 mData->mChangeFlags |= RadioStation::PsTypeChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 */
 void RadioStation::setRadioText( const QString& radioText )
 {
 if ( mData->mRadioText.compare( radioText ) != 0 ) {
-detach();
 mData->mRadioText = radioText.isEmpty() ? "" : radioText.trimmed();
 mData->mChangeFlags |= RadioStation::RadioTextChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 if ( rtPlusClass == RtPlus::Homepage ) {
 setUrl( rtPlusItem );
 return;
 }
-detach();
 QString replacement = "";
 if ( rtPlusClass == RtPlus::Artist ) {
 replacement = HTML_ARTIST;
 } else if ( rtPlusClass == RtPlus::Title ) {
 replacement = HTML_TITLE;
 *
 */
 void RadioStation::setDynamicPsText( const QString& dynamicPsText )
 {
 if ( mData->mDynamicPsText.compare( dynamicPsText ) != 0 ) {
-detach();
 mData->mDynamicPsText = dynamicPsText;
 mData->mChangeFlags |= RadioStation::DynamicPsChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 */
 bool RadioStation::isValid() const
 {
-return mData->mPresetIndex >= 0 && mData->mFrequency > 0;
+return mData->mFrequency > 0 && ( isType( ManualStation ) || mData->mPresetIndex >= 0 );
 }
 /*!
 *
 */
 void RadioStation::setUserDefinedName( const QString& name )
 {
 // We don't check for name emptiness because this setter is used also to remove the renaming
 // of a station by setting an empty name
 if ( mData->mName.compare( name ) != 0 ) {
-detach();
 mData->mName = name;
 mData->mRenamedByUser = !name.isEmpty();
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::NameChanged;
 }
 }
 }
 /*!
 *
 */
-QString RadioStation::frequencyMhz() const
+QString RadioStation::frequencyString() const
 {
-return qtTrId( "txt_rad_list_l1_mhz_big" ).arg( parseFrequency( mData->mFrequency ) );
+return parseFrequency( mData->mFrequency );
-}
-/*!
-*
-*/
-QString RadioStation::nameOrFrequencyMhz() const
-{
-if ( !mData->mName.isEmpty() ) {
-return mData->mName;
-}
-return frequencyMhz();
 }
 /*!
 *
 */
 *
 */
 void RadioStation::setFavorite( bool favorite )
 {
 if ( isFavorite() != favorite ) {
-detach();
 favorite ? setType( RadioStation::Favorite ) : unsetType( RadioStation::Favorite );
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::FavoriteChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 *
 */
 bool RadioStation::hasRds() const
 {
 return hasPiCode() ||
 mData->mGenre != -1 ||
 !mData->mDynamicPsText.isEmpty() ||
 !mData->mRadioText.isEmpty() ||
 ( !mData->mName.isEmpty() && !isRenamed() );
 }
 /*!
 *
 */
 void RadioStation::setType( RadioStation::Type type )
 {
 if ( !isType( type ) ) {
-detach();
 // Check if favorite-status changed
 if ( mData->mType.testFlag( RadioStation::Favorite ) != type.testFlag( RadioStation::Favorite ) ) {
 mData->mChangeFlags |= RadioStation::FavoriteChanged;
 }
 mData->mType |= type;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::TypeChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 */
 void RadioStation::unsetType( RadioStation::Type type )
 {
 if ( isType( type ) ) {
-detach();
 // Check if favorite-status changed
 if ( mData->mType.testFlag( RadioStation::Favorite ) != type.testFlag( RadioStation::Favorite ) ) {
 mData->mChangeFlags |= RadioStation::FavoriteChanged;
 }
 mData->mType &= ~type;
 mData->mChangeFlags |= RadioStation::PersistentDataChanged | RadioStation::TypeChanged;
+ASSERT_SHARED_NULL_IS_INTACT
 }
 }
 /*!
 *
 *
 */
 void RadioStation::resetChangeFlags()
 {
 if ( mData->mChangeFlags != RadioStation::NoChange ) {
-detach();
 mData->mChangeFlags = RadioStation::NoChange;
-}
-}
-/**
-* Decrements the reference count of the implicitly shared data.
-*/
-void RadioStation::decrementReferenceCount()
-{
-if ( !mData->ref.deref() ) {
-delete mData;
-mData = 0;
 }
 }
 /*!
 *
 {
 QString callSign;
 LOG_FORMAT( "RadioStation::piCodeToCallSign PI: %d", programmeIdentification );
 // call signs beginning with 'K'
-if( ( programmeIdentification>=KXXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification < WXXX_CALLSIGN_PI_FIRST ) ) {
+if ( ( programmeIdentification>=KXXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification < WXXX_CALLSIGN_PI_FIRST ) ) {
 callSign += "K";
 callSign += iterateCallSign( KXXX_CALLSIGN_PI_FIRST, programmeIdentification );
 }
 // call signs beginning with 'W'
-else if (( programmeIdentification >= WXXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification <= WXXX_CALLSIGN_PI_LAST )) {
+else if ( ( programmeIdentification >= WXXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification <= WXXX_CALLSIGN_PI_LAST ) ) {
 callSign += "W";
 callSign += iterateCallSign( WXXX_CALLSIGN_PI_FIRST, programmeIdentification );
 }
 // 3 letter only call signs
-else if(( programmeIdentification >= XXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification <= XXX_CALLSIGN_PI_LAST)) {
+else if ( ( programmeIdentification >= XXX_CALLSIGN_PI_FIRST ) && ( programmeIdentification <= XXX_CALLSIGN_PI_LAST ) ) {
 callSign += callSignString( programmeIdentification );
-}
+} else {
-else
-{
 LOG( "RadioStation::piCodeToCallSign - Unhandled else" );
 }
 LOG_FORMAT( "RadioStation::piCodeToCallSign, call sign: %s", GETSTRING(callSign) );
 QString RadioStation::iterateCallSign( int piBase, int programmeIdentification )
 {
 QString callSign;
 LOG_FORMAT( "RadioStation::iterateCallSign base: %d", piBase );
-int sum(0), i(0);
+int sum = 0;
+int i = 0;
 while( sum < programmeIdentification ) {
-i++;
+++i;
 sum = piBase + i * 676 + 0 + 0;
 }
 callSign += callSignChar( i - 1 );
 int tmpSum( sum - 676 );
 sum -= 676;
 i = 0;
 while( sum <= programmeIdentification ) {
-i++;
+++i;
 sum = tmpSum + 0 + i * 26 + 0;
 }
 callSign += callSignChar( i - 1 );
 tmpSum = sum - 26;
 sum -= 26;
 i = 0;
 while( sum <= programmeIdentification ) {
-i++;
+++i;
 sum = tmpSum + 0 + 0 + i;
 }
 callSign += callSignChar( i - 1 );
 return callSign;
 }
 }
 LOG_FORMAT( "RadioStation::callSignString, Not found PI: %d", programmeIdentification );
-return QString("????");
+return QString( "????" );
 }
 /*!
 *
 */
 }
 return '?';
 }
 /**
-* Detach from the implicitly shared data
-*/
-void RadioStation::detach()
-{
-if ( !isDetached() ) {
-RadioStationPrivate* newData = new RadioStationPrivate( *mData );
-decrementReferenceCount();
-newData->ref = 1;
-mData = newData;
-// The shared null instance of the data has its preset index set to -200 (RadioStation::SharedNull).
-// We change the preset index of the detached data to -100 (RadioStation::Invalid) just to ease
-// debugging. This guarantees that the only instance that has value -200 is the actual shared null.
-#ifdef _DEBUG
-if ( mData->mPresetIndex == RadioStation::SharedNull ) {
-mData->mPresetIndex = RadioStation::Invalid;
-}
-#endif
-}
-}
-/**
 * Checks if the class is detached from implicitly shared data
 */
 bool RadioStation::isDetached() const
 {
 return mData->ref == 1;

changeset 32	189d20c34778
parent 28	075425b8d9a4
child 33	11b6825f0862