Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

Buteo |
AccountsHelper | Helper Class towards Accounts::Manager and various SSO related operations
ClientPluginRunner | Class for running client sync plug-ins
ClientThread | Thread for client plugins
IPHeartBeat | IPHeartBeat implementation
PluginRunner | Base class for running sync plug-ins
ServerActivator | Keeps track of which server plug-ins should be enabled
ServerPluginRunner | Class for running server sync plug-ins
ServerThread | Thread for server plugin
StorageBooker | A helper class for managing storage reservations
StorageChangeNotifier | Notifies about changes in storages that it's asked to monitor
SyncBackup | Handles Sync requirements towards Backup
SyncBackupAdaptor | Adaptor class for interface com.nokia.backupclient
SyncBackupProxy | Defines a D-Bus backup proxy for the backupclient
SyncDBusInterface | Defines a D-Bus interface for the sync daemon
Synchronizer | The main entry point to the synchronization framework
SyncOnChange | This class initiates a sync if there are changes in storage(s) it's asked to monitor
SyncOnChangeScheduler |
SyncOnChangeTimer |
SyncQueue | Class for queuing sync sessions
SyncScheduler | SyncScheduler Object to be used to set Schedule via the framework
SyncSession | Class representing a single sync session
SyncClientInterface | SyncInterface Class - Main Entry Point for SyncFW Clients
SyncClientInterfacePrivate | Private implementation class for SyncClientInterface
LogTimer | Helper class for timing function execution time
NetworkManager | Class for managing network sessions
TransportTracker | Class for tracking transport states

USBModedProxy

- Proxy class for interface com.meego.usb_moded

ClientPlugin | Base class for client plugins
DeletedItemsIdStorage | Persistent storage for storing deleted item IDs
OOPClientPlugin |
OOPServerPlugin |
PluginCbInterface | Interface which client and server plugins can use to communicate with synchronization daemon
PluginManager | Manages plugins
ServerPlugin | Base class for server plugins
StorageChangeNotifierPlugin | Implement this class to notify about changes in a specific storage - contacts/calendar/sms, or even custom ones like a facebook storage, if there's such a storage on the device
StorageChangeNotifierPluginLoader | Base class for storage change notifier plugin loaders
StorageItem | Class to describe a storable item
StoragePlugin | Base class for storage plugins
StoragePluginLoader | Base class for storage plugin loaders
SyncPluginBase | Base class for client and server plugins
ReceivedItemDetails |
SyncPluginLoader | Base class for sync plugin loaders
BtHelper | Implementation for bluetooth helper utils
Profile | This class represents a single profile, a collection of settings or data releated to some entity
ProfilePrivate | Private implementation class for Profile class
ProfileFactory | ProfileFactory handles creating Profile instances
ProfileField | This class represents a profile field
ProfileManager | ProfileManager is responsible for storing and retrieving the profiles
SearchCriteria | Search criteria for finding profiles
StorageProfile | Storage Profile Class
SyncLog | History of completed synchronization sessions and their results
SyncProfile | A top level synchronization profile
DatabaseResults |
SyncResults | Contains information about a completed synchronization session
SyncSchedule | Class for handling sync schedule settings
SyncSchedulePrivate | Private implementation class for SyncSchedule
ItemCounts | Container for number of items added, deleted and modified
TargetResults | Sync results for one target
BackgroundSync | BackgroundSync implementation
ButeoPluginIface |
QList |
QMap |
SyncAlarmInventory | Class for storing alarms
SyncDaemonProxy | Proxy class for interface com.meego.msyncd
SyncDBusAdaptor |

SyncSigHandler

About this class. We can't call Qt functions from Unix signal handlers. We can only call async-signal-safe functions from signal handlers. So this provides a way to use Unix signal handlers with Qt. The strategy is to have our Unix signal handler will eventually cause a Qt signal to be emitted, and then we simply return from our Unix signal handler. Back in our Qt program, that Qt signal gets emitted and then received by our Qt slot function, where we are safely doing Qt stuff which weren't allowed to do in the Unix signal handler. One simple way to make this happen is declares a socket pair in our class for each Unix signal we want to handle. The socket pairs are declared as static data members.We also created a QSocketNotifier to monitor the read end of each socket pair, declare your Unix signal handlers to be static class methods, and declare a slot function corresponding to each of our Unix signal handlers. In this class, we intend to handle both the SIGHUP and SIGTERM signals