Creates a state info from a new meta info to use with a k/v state.

<p>Creates the column family for the state.
Sets TTL compaction filter if {@code ttlCompactFiltersManager} is not {@code null}.
513021
public static RocksDBKeyedStateBackend.RocksDbKvStateInfo createStateInfo(
		RegisteredStateMetaInfoBase metaInfoBase,
		RocksDB db,
		Function<String, ColumnFamilyOptions> columnFamilyOptionsFactory,
		@Nullable RocksDbTtlCompactFiltersManager ttlCompactFiltersManager) {

		ColumnFamilyDescriptor columnFamilyDescriptor = createColumnFamilyDescriptor(
			metaInfoBase, columnFamilyOptionsFactory, ttlCompactFiltersManager);
		return new RocksDBKeyedStateBackend.RocksDbKvStateInfo(createColumnFamily(columnFamilyDescriptor, db), metaInfoBase);
	}
59158
public void setVerificationState(java.util.Collection<StringFilter> verificationState) {
        if (verificationState == null) {
            this.verificationState = null;
            return;
        }

        this.verificationState = new java.util.ArrayList<StringFilter>(verificationState);
    }
889161
public static List<HBaseConsumerState> create(SortedMap<byte[], byte[]> stateMap) {
    List<HBaseConsumerState> states = new ArrayList<HBaseConsumerState>(stateMap.size());
    for (Map.Entry<byte[], byte[]> entry : stateMap.entrySet()) {
      // Intentionally using HBase Bytes.
      long groupId = Bytes.toLong(entry.getKey());
      int instanceId = Bytes.toInt(entry.getKey(), LONG_BYTES);
      states.add(new HBaseConsumerState(entry.getValue(), groupId, instanceId));
    }
    return states;
  }
1139506
@Override
  public <T extends Filter> T createFilter(Class<T> classToCreate) throws ServletException {
      
      logger.logp(Level.FINE, CLASS_NAME, "createFilter", "called for class: " + classToCreate);
      return super.createFilter(classToCreate);
  }
74937
private D createAndRegisterDeclaration(Map<String, Object> metadata) {
        D declaration;
        if (klass.equals(ImportDeclaration.class)) {
            declaration = (D) ImportDeclarationBuilder.fromMetadata(metadata).build();
        } else if (klass.equals(ExportDeclaration.class)) {
            declaration = (D) ExportDeclarationBuilder.fromMetadata(metadata).build();
        } else {
            throw new IllegalStateException("");
        }
        declarationRegistrationManager.registerDeclaration(declaration);
        return declaration;
    }
228569
public Filter create(byte[] family, byte[] column, byte[] value)
    {
        return new SingleColumnValueFilter(family, column, operator, comparatorFactory.apply(value));
    }
266215
@Override
    public void create(SchemaMigrationMetadata metadata) {
        session.execute(
                insertInto(METADATA_TABLE)
                        .ifNotExists()
                        .value(ID_COL, metadata.getId())
                        .value(INDEX_COL, metadata.getIndex())
                        .value(TOKEN_COL, metadata.getToken())
                        .value(STATUS_COL, metadata.getStatus().name())
                        .value(FINGERPRINT_COL, metadata.getFingerprint()));
    }
405410
@Override
	public SqlContext createBatchInsertContext(final SqlAgent agent, final TableMetadata metadata,
			final Class<? extends Object> entityType) {
		return agent.contextWith(buildInsertSQL(metadata, entityType, agent.getSqlConfig(), false))
				.setSqlId(createSqlId(metadata, entityType));
	}
1002841
private FilterTable createTable() throws IOException, CmsException {

        final FilterTable table = new FilterTable();
        table.setSizeFull();

        table.setContainerDataSource(m_model.getContainerForCurrentLocale());

        table.setColumnHeader(TableProperty.KEY, m_configurableMessages.getColumnHeader(TableProperty.KEY));
        table.setColumnCollapsible(TableProperty.KEY, false);

        table.setColumnHeader(TableProperty.DEFAULT, m_configurableMessages.getColumnHeader(TableProperty.DEFAULT));
        table.setColumnCollapsible(TableProperty.DEFAULT, true);

        table.setColumnHeader(
            TableProperty.DESCRIPTION,
            m_configurableMessages.getColumnHeader(TableProperty.DESCRIPTION));
        table.setColumnCollapsible(TableProperty.DESCRIPTION, true);

        table.setColumnHeader(
            TableProperty.TRANSLATION,
            m_configurableMessages.getColumnHeader(TableProperty.TRANSLATION));
        table.setColumnCollapsible(TableProperty.TRANSLATION, false);

        table.setColumnHeader(TableProperty.OPTIONS, m_configurableMessages.getColumnHeader(TableProperty.OPTIONS));
        table.setFilterDecorator(new CmsMessageBundleEditorFilterDecorator());

        table.setFilterBarVisible(true);
        table.setColumnCollapsible(TableProperty.OPTIONS, false);

        table.setSortEnabled(true);
        table.setEditable(true);

        table.setSelectable(true);
        table.setImmediate(true);
        table.setMultiSelect(false);

        table.setColumnCollapsingAllowed(m_model.hasDescriptor());

        table.setColumnReorderingAllowed(false);

        m_optionsColumn = generateOptionsColumn(table);

        if (m_model.isShowOptionsColumn(m_model.getEditMode())) {
            table.setFilterFieldVisible(TableProperty.OPTIONS, false);
            table.addGeneratedColumn(TableProperty.OPTIONS, m_optionsColumn);
        }
        table.setColumnWidth(TableProperty.OPTIONS, CmsMessageBundleEditorTypes.OPTION_COLUMN_WIDTH);
        table.setColumnExpandRatio(TableProperty.KEY, 1f);
        table.setColumnExpandRatio(TableProperty.DESCRIPTION, 1f);
        table.setColumnExpandRatio(TableProperty.DEFAULT, 1f);
        table.setColumnExpandRatio(TableProperty.TRANSLATION, 1f);

        table.setPageLength(30);
        table.setCacheRate(1);
        table.sort(new Object[] {TableProperty.KEY}, new boolean[] {true});
        table.addContextClickListener(new ContextClickListener() {

            private static final long serialVersionUID = 1L;

            public void contextClick(ContextClickEvent event) {

                Object itemId = m_table.getValue();
                CmsContextMenu contextMenu = m_model.getContextMenuForItem(itemId);
                if (null != contextMenu) {
                    contextMenu.setAsContextMenuOf(m_table);
                    contextMenu.setOpenAutomatically(false);
                    contextMenu.open(event.getClientX(), event.getClientY());
                }
            }
        });
        table.setNullSelectionAllowed(false);
        table.select(table.getCurrentPageFirstItemId());
        return table;
    }
118181
@Override
    public void createTableIfDoesNotExist(final String tableName, final String... colFamily)
            throws MasterNotRunningException, IOException
    {
        if (!admin.tableExists(Bytes.toBytes(tableName)))
        {
            HTableDescriptor htDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
            for (String columnFamily : colFamily)
            {
                HColumnDescriptor familyMetadata = new HColumnDescriptor(columnFamily);
                htDescriptor.addFamily(familyMetadata);
            }
            admin.createTable(htDescriptor);
        }
    }
746820
protected TableMetaReader createTableMetaReader() {
    return globalFactory.createTableMetaReader(
        dialect, dataSource, schemaName, tableNamePattern, ignoredTableNamePattern, tableTypes);
  }
1155437
private void createNewState(AbstractBaseDTNode<I, D> newNode) {
        TTTTransition<I, D> newTreeTrans = newNode.getIncoming().choose();
        assert newTreeTrans != null;

        TTTState<I, D> newState = createState(newTreeTrans);
        link(newNode, newState);
        initializeState(newState);
    }
321731
protected void createRealizationAndState(
                                             MessageProcessor messageProcessor,
                                             TransactionCommon transaction)
                    throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "createRealizationAndState",
                        new Object[] {
                                      messageProcessor,
                                      transaction });

        /*
         * Create associated protocol suppor of appropriate type
         */
        if (isPubSub())
        {
            _pubSubRealization = new PubSubRealization(this,
                            messageProcessor,
                            getLocalisationManager(),
                            transaction);
            _protoRealization = _pubSubRealization;
        }
        else
        {

            _ptoPRealization = new JSPtoPRealization(this,
                            messageProcessor,
                            getLocalisationManager());
            _protoRealization = _ptoPRealization;

        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "createRealizationAndState");
    }
899203
public static VisitorState createForUtilityPurposes(Context context) {
    return new VisitorState(
        context,
        VisitorState::nullListener,
        ImmutableMap.of(),
        ErrorProneOptions.empty(),
        // Can't use this VisitorState to report results, so no-op collector.
        StatisticsCollector.createNoOpCollector(),
        null,
        null,
        SuppressedState.UNSUPPRESSED);
  }
1337053
private void createNewState(DTNode<I> newNode) {
        LOGGER.debug("Create new state");
        AbstractHypTrans<I> newTreeTrans = newNode.getIncoming().chooseMinimal();
        assert newTreeTrans != null;

        HypLoc<I> newLoc = makeTree(newTreeTrans);
        link(newNode, newLoc);
        initializeLocation(newLoc);
    }
600611
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        italicFont = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Roboto-Italic.ttf");
        regularFont = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Roboto-Regular.ttf");
        boldItalicFont = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Roboto-BoldItalic.ttf");
    }
1282435
private void createColumnFamilies(List<TableInfo> tableInfos, KsDef ksDef) throws Exception
    {
        for (TableInfo tableInfo : tableInfos)
        {
            if (isCql3Enabled(tableInfo))
            {
                createOrUpdateUsingCQL3(tableInfo, ksDef);
                createIndexUsingCql(tableInfo);
            }
            else
            {
                createOrUpdateColumnFamily(tableInfo, ksDef);
            }

            // Create Inverted Indexed Table if required.
            createInvertedIndexTable(tableInfo, ksDef);
        }
    }