Coverage Summary for Class: MonitoringDatabase_Impl (cloud.mindbox.mobile_sdk.monitoring.data.room)

 package cloud.mindbox.mobile_sdk.monitoring.data.room;
 
 import androidx.annotation.NonNull;
 import androidx.room.DatabaseConfiguration;
 import androidx.room.InvalidationTracker;
 import androidx.room.RoomDatabase;
 import androidx.room.RoomOpenHelper;
 import androidx.room.migration.AutoMigrationSpec;
 import androidx.room.migration.Migration;
 import androidx.room.util.DBUtil;
 import androidx.room.util.TableInfo;
 import androidx.sqlite.db.SupportSQLiteDatabase;
 import androidx.sqlite.db.SupportSQLiteOpenHelper;
 import cloud.mindbox.mobile_sdk.monitoring.data.room.dao.MonitoringDao;
 import cloud.mindbox.mobile_sdk.monitoring.data.room.dao.MonitoringDao_Impl;
 import java.lang.Class;
 import java.lang.Override;
 import java.lang.String;
 import java.lang.SuppressWarnings;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.annotation.processing.Generated;
 
 @Generated("androidx.room.RoomProcessor")
 @SuppressWarnings({"unchecked", "deprecation"})
 public final class MonitoringDatabase_Impl extends MonitoringDatabase {
   private volatile MonitoringDao _monitoringDao;
 
   @Override
   @NonNull
   protected SupportSQLiteOpenHelper createOpenHelper(@NonNull final DatabaseConfiguration config) {
     final SupportSQLiteOpenHelper.Callback _openCallback = new RoomOpenHelper(config, new RoomOpenHelper.Delegate(2) {
       @Override
       public void createAllTables(@NonNull final SupportSQLiteDatabase db) {
         db.execSQL("CREATE TABLE IF NOT EXISTS `mb_monitoring` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `timestamp` TEXT NOT NULL, `log` TEXT NOT NULL)");
         db.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)");
         db.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'd8a714418753fef6b4f7ce8daaaf5331')");
       }
 
       @Override
       public void dropAllTables(@NonNull final SupportSQLiteDatabase db) {
         db.execSQL("DROP TABLE IF EXISTS `mb_monitoring`");
         final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
         if (_callbacks != null) {
           for (RoomDatabase.Callback _callback : _callbacks) {
             _callback.onDestructiveMigration(db);
           }
         }
       }
 
       @Override
       public void onCreate(@NonNull final SupportSQLiteDatabase db) {
         final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
         if (_callbacks != null) {
           for (RoomDatabase.Callback _callback : _callbacks) {
             _callback.onCreate(db);
           }
         }
       }
 
       @Override
       public void onOpen(@NonNull final SupportSQLiteDatabase db) {
         mDatabase = db;
         internalInitInvalidationTracker(db);
         final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
         if (_callbacks != null) {
           for (RoomDatabase.Callback _callback : _callbacks) {
             _callback.onOpen(db);
           }
         }
       }
 
       @Override
       public void onPreMigrate(@NonNull final SupportSQLiteDatabase db) {
         DBUtil.dropFtsSyncTriggers(db);
       }
 
       @Override
       public void onPostMigrate(@NonNull final SupportSQLiteDatabase db) {
       }
 
       @Override
       @NonNull
       public RoomOpenHelper.ValidationResult onValidateSchema(
           @NonNull final SupportSQLiteDatabase db) {
         final HashMap<String, TableInfo.Column> _columnsMbMonitoring = new HashMap<String, TableInfo.Column>(3);
         _columnsMbMonitoring.put("id", new TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
         _columnsMbMonitoring.put("timestamp", new TableInfo.Column("timestamp", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
         _columnsMbMonitoring.put("log", new TableInfo.Column("log", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
         final HashSet<TableInfo.ForeignKey> _foreignKeysMbMonitoring = new HashSet<TableInfo.ForeignKey>(0);
         final HashSet<TableInfo.Index> _indicesMbMonitoring = new HashSet<TableInfo.Index>(0);
         final TableInfo _infoMbMonitoring = new TableInfo("mb_monitoring", _columnsMbMonitoring, _foreignKeysMbMonitoring, _indicesMbMonitoring);
         final TableInfo _existingMbMonitoring = TableInfo.read(db, "mb_monitoring");
         if (!_infoMbMonitoring.equals(_existingMbMonitoring)) {
           return new RoomOpenHelper.ValidationResult(false, "mb_monitoring(cloud.mindbox.mobile_sdk.monitoring.data.room.entities.MonitoringEntity).\n"
                   + " Expected:\n" + _infoMbMonitoring + "\n"
                   + " Found:\n" + _existingMbMonitoring);
         }
         return new RoomOpenHelper.ValidationResult(true, null);
       }
     }, "d8a714418753fef6b4f7ce8daaaf5331", "a4b63c1cca619b8f8c7a2617427805dd");
     final SupportSQLiteOpenHelper.Configuration _sqliteConfig = SupportSQLiteOpenHelper.Configuration.builder(config.context).name(config.name).callback(_openCallback).build();
     final SupportSQLiteOpenHelper _helper = config.sqliteOpenHelperFactory.create(_sqliteConfig);
     return _helper;
   }
 
   @Override
   @NonNull
   protected InvalidationTracker createInvalidationTracker() {
     final HashMap<String, String> _shadowTablesMap = new HashMap<String, String>(0);
     final HashMap<String, Set<String>> _viewTables = new HashMap<String, Set<String>>(0);
     return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "mb_monitoring");
   }
 
   @Override
   public void clearAllTables() {
     super.assertNotMainThread();
     final SupportSQLiteDatabase _db = super.getOpenHelper().getWritableDatabase();
     try {
       super.beginTransaction();
       _db.execSQL("DELETE FROM `mb_monitoring`");
       super.setTransactionSuccessful();
     } finally {
       super.endTransaction();
       _db.query("PRAGMA wal_checkpoint(FULL)").close();
       if (!_db.inTransaction()) {
         _db.execSQL("VACUUM");
       }
     }
   }
 
   @Override
   @NonNull
   protected Map<Class<?>, List<Class<?>>> getRequiredTypeConverters() {
     final HashMap<Class<?>, List<Class<?>>> _typeConvertersMap = new HashMap<Class<?>, List<Class<?>>>();
     _typeConvertersMap.put(MonitoringDao.class, MonitoringDao_Impl.getRequiredConverters());
     return _typeConvertersMap;
   }
 
   @Override
   @NonNull
   public Set<Class<? extends AutoMigrationSpec>> getRequiredAutoMigrationSpecs() {
     final HashSet<Class<? extends AutoMigrationSpec>> _autoMigrationSpecsSet = new HashSet<Class<? extends AutoMigrationSpec>>();
     return _autoMigrationSpecsSet;
   }
 
   @Override
   @NonNull
   public List<Migration> getAutoMigrations(
       @NonNull final Map<Class<? extends AutoMigrationSpec>, AutoMigrationSpec> autoMigrationSpecs) {
     final List<Migration> _autoMigrations = new ArrayList<Migration>();
     return _autoMigrations;
   }
 
   @Override
   public MonitoringDao monitoringDao() {
     if (_monitoringDao != null) {
       return _monitoringDao;
     } else {
       synchronized(this) {
         if(_monitoringDao == null) {
           _monitoringDao = new MonitoringDao_Impl(this);
         }
         return _monitoringDao;
       }
     }
   }
 }