<p>readMigrations.</p>
178943
protected void readMigrations() {
        final List<MigrationResource> resources = findMigrationResource();

        // sort into version order before applying
        Collections.sort(resources);

        for (MigrationResource migrationResource : resources) {
            logger.debug("read {}", migrationResource);
            model.apply(migrationResource.read(), migrationResource.getVersion());
        }

        // remember the last version
        if (!resources.isEmpty()) {
            lastVersion = resources.get(resources.size() - 1).getVersion();
        }
    }
1155553
public void scan(List<? extends JCTree> trees) {
        if (trees != null)
        for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
            scan(l.head);
    }


/* ***************************************************************************
 * Visitor methods
 ****************************************************************************/

    public void visitTopLevel(JCCompilationUnit tree) {
        scan(tree.defs);
    }

    public void visitPackageDef(JCPackageDecl tree) {
        scan(tree.annotations);
        scan(tree.pid);
    }

    @Override
    public void visitModuleDef(JCModuleDecl tree) {
        scan(tree.mods);
        scan(tree.qualId);
        scan(tree.directives);
    }

    @Override
    public void visitExports(JCExports tree) {
        scan(tree.qualid);
        scan(tree.moduleNames);
    }

    @Override
    public void visitOpens(JCOpens tree) {
        scan(tree.qualid);
        scan(tree.moduleNames);
    }

    @Override
    public void visitProvides(JCProvides tree) {
        scan(tree.serviceName);
        scan(tree.implNames);
    }

    @Override
    public void visitRequires(JCRequires tree) {
        scan(tree.moduleName);
    }

    @Override
    public void visitUses(JCUses tree) {
        scan(tree.qualid);
    }

    public void visitImport(JCImport tree) {
        scan(tree.qualid);
    }

    public void visitClassDef(JCClassDecl tree) {
        scan(tree.mods);
        scan(tree.typarams);
        scan(tree.extending);
        scan(tree.implementing);
        scan(tree.defs);
    }

    public void visitMethodDef(JCMethodDecl tree) {
        scan(tree.mods);
        scan(tree.restype);
        scan(tree.typarams);
        scan(tree.recvparam);
        scan(tree.params);
        scan(tree.thrown);
        scan(tree.defaultValue);
        scan(tree.body);
    }

    public void visitVarDef(JCVariableDecl tree) {
        scan(tree.mods);
        scan(tree.vartype);
        scan(tree.nameexpr);
        scan(tree.init);
    }

    public void visitSkip(JCSkip tree) {
    }
174857
private void readObject(final java.io.ObjectInputStream s)  throws IOException, ClassNotFoundException {
        // Read in the threshold (ignored), and any hidden stuff
        s.defaultReadObject();

        // set other fields that need values
        keys = EMPTY;
        values = EMPTY;

        // Read in number of buckets
        final int capacity = s.readInt();
        if (capacity < 0) {
            throw new InvalidObjectException("Illegal capacity: " + capacity);
        }

        // Read number of mappings
        final int mappings = s.readInt();
        if (mappings < 0) {
            throw new InvalidObjectException("Illegal mappings count: " + mappings);
        }

        // allocate the bucket array;
        if (mappings > 0) {
            inflateTable(capacity);
        } else {
            threshold = capacity;
        }

        // Read the keys and values, and put the mappings in the arrays
        for (int i = 0; i < mappings; i++) {
            keys[i] = (String) s.readObject();
            try {
                final byte[] marshalledObject = (byte[]) s.readObject();
                values[i] = marshalledObject == null ? null : unmarshall(marshalledObject);
            } catch (final Exception | LinkageError error) {
                handleSerializationException(error, i, keys[i]);
                values[i] = null;
            }
        }
        size = mappings;
    }
1259548
public java.util.List<String> getImports() {
        if (imports == null) {
            imports = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return imports;
    }
601853
private function buildMigrations()
    {
        $unitDataArray = $this->loadUnitDataIteratorFromDatabase();
        foreach ($unitDataArray as $unitData) {
            $unitOfWork = UnitOfWorkFactory::BuildFromFlatArray($unitData);
            $this->presentUidsOnConstruction[$unitOfWork->getUniqueId()] = true;
            $this->add($unitOfWork);
        }
    }
43973
public void migrate(File fromSource, File toDest) {
        IReaderHandler readerHandler = this;
        try (IDataMigratorReader reader = new JsonDataMigratorReader(fromSource);
             IDataMigratorWriter writer = new JsonDataMigratorWriter(toDest)) {
            this.writer = writer;
            reader.read(readerHandler);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
769207
private Map<C, Long> readLockColumns(boolean readDataColumns) throws Exception {
        Map<C, Long> result = Maps.newLinkedHashMap();
        // Read all the columns
        if (readDataColumns) {
            columns = new OrderedColumnMap<C>();
            ColumnList<C> lockResult = keyspace
                .prepareQuery(columnFamily)
                    .setConsistencyLevel(consistencyLevel)
                    .getKey(key)
                .execute()
                    .getResult();
    
            for (Column<C> c : lockResult) {
                if (columnStrategy.isLockColumn(c.getName()))
                    result.put(c.getName(), readTimeoutValue(c));
                else 
                    columns.add(c);
            }
        }
        // Read only the lock columns
        else {
            ColumnList<C> lockResult = keyspace
                .prepareQuery(columnFamily)
                    .setConsistencyLevel(consistencyLevel)
                    .getKey(key)
                    .withColumnRange(columnStrategy.getLockColumnRange())
                .execute()
                    .getResult();

            for (Column<C> c : lockResult) {
                result.put(c.getName(), readTimeoutValue(c));
            }

        }
        return result;    
    }
1233428
@Override
    public List readAll(final String tableName, Class clazz, EntityMetadata m, final List<Object> rowKey,
            List<String> relationNames, String... columns) throws IOException
    {

        List output = null;

        Object entity = null;

        HTableInterface hTable = null;

        hTable = gethTable(tableName);

        // Load raw data from HBase
        MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
                m.getPersistenceUnit());

        AbstractManagedType managedType = (AbstractManagedType) metaModel.entity(m.getEntityClazz());
        // For secondary tables.
        List<String> secondaryTables = ((DefaultEntityAnnotationProcessor) managedType.getEntityAnnotation())
                .getSecondaryTablesName();
        secondaryTables.add(m.getTableName());
        List<HBaseData> results = new ArrayList<HBaseData>();
        for (String colTableName : secondaryTables)
        {
            List table = ((HBaseReader) hbaseReader).loadAll(hTable, rowKey, colTableName, columns);
            // null check for 'table'. addAll method throws exception if table
            // is null
            if (table != null)
            {
                results.addAll(table);
            }
        }

        output = onRead(tableName, clazz, m, output, hTable, entity, relationNames, results);
        return output;
    }
554273
public java.util.List<String> getReaders() {
        if (readers == null) {
            readers = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return readers;
    }
1231187
public static void main(String[] args) {
        File from;
        File to;
        
        if (args.length < 2) {
            System.out.println("Usage:  DataMigrator <pathToSourceFile> <pathToDestFile>"); //$NON-NLS-1$
            return;
        }
        
        String frompath = args[0];
        String topath = args[1];
        
        from = new File(frompath);
        to = new File(topath);

        System.out.println("Starting data migration."); //$NON-NLS-1$
        System.out.println("  From: " + from); //$NON-NLS-1$
        System.out.println("  To:   " + to); //$NON-NLS-1$
        DataMigrator migrator = new DataMigrator();
        migrator.setLogger(new SystemOutLogger());
        Version version = new Version();
        version.postConstruct();
        migrator.setVersion(version);
        migrator.migrate(from, to);
    }
1246100
private void readPropertiesFiles() {

        if (this.messageFileWildcard.isEmpty() || !CoreParameters.LOG_RESOLUTION.get()) {
            // Skip configuration loading
            LOGGER.info(JRebirthMarkers.MESSAGE, "Messages Loading is skipped");

        } else {
            // Assemble the regex pattern
            final Pattern filePattern = Pattern.compile(this.messageFileWildcard + "\\.properties");

            // Retrieve all resources from default classpath
            final Collection<String> list = ClasspathUtility.getClasspathResources(filePattern);

            LOGGER.info(JRebirthMarkers.MESSAGE, "{} Messages file{} found.", list.size(), list.size() > 1 ? "s" : "");

            for (final String rbFilename : list) {
                readPropertiesFile(rbFilename);
            }
        }
    }
426389
public Properties readProperties() throws IOException {
        Properties p;

        try (Reader src = newReader()) {
            p = new Properties();
            p.load(src);
        }
        return p;
    }
788683
public synchronized void removeMPReadTransactions() {
        TransactionTask  task = m_backlog.peekFirst();
        while (task != null && task.getTransactionState().isReadOnly()) {
            task.getTransactionState().setDone();
            flush(task.getTxnId());
            task = m_backlog.peekFirst();
        }
    }
405418
public void processExports(AModuleModules m)
	{
		if (m.getExports() != null)
		{
			m.getExportdefs().clear();
			
			if (!m.getIsDLModule())
			{
				m.getExportdefs().addAll(getDefinitions(m.getExports(), m.getDefs()));
			} else
			{
				m.getExportdefs().addAll(getDefinitions(m.getExports()));
			}
		}
	}
1034505
private void read() {
        // define the specification format
        final int key = 0;
        final int description = 1;
        final int offset = 2;
        final int length = 3;
        SpecificationFormat format = new SpecificationFormat(key, description,
                offset, length);
        // read the header data
        try {
            data = IOUtil.readHeaderEntries(COFFHeaderKey.class, format,
                    COFF_SPEC_FILE, headerbytes, getOffset());
        } catch (IOException e) {
            logger.error("unable to read coff specification: " + e.getMessage());
        }
    }
289930
public void updateMetadataVersions() {
        Properties versionProps = MetadataVersionStoreUtils.getProperties(this.systemStoreRepository.getMetadataVersionStore());
        Long newVersion = fetchNewVersion(SystemStoreConstants.CLUSTER_VERSION_KEY,
                                          null,
                                          versionProps);
        if(newVersion != null) {
            this.currentClusterVersion = newVersion;
        }
    }
598408
public void readConnections(ConfigParams connections) {
		synchronized (_lock) {
			_items.clear();
			for (Map.Entry<String, String> entry : connections.entrySet()) {
				DiscoveryItem item = new DiscoveryItem();
				item.key = entry.getKey();
				item.connection = ConnectionParams.fromString(entry.getValue());
				_items.add(item);
			}
		}
	}