statement.setString(14, results.getHost());
            statement.setString(15, results.getTeamCityBuildId());
            statement.execute();
            ResultSet keys = statement.getGeneratedKeys();
            keys.next();
            return keys.getLong(1);
        }
    }

    private void insertExecutionExperiment(Connection connection, R results) throws SQLException {

        if (!declarationsBySchemaFunctions.isEmpty()) {
            collectorDeclarationsByClass[kClass] = declarationsBySchemaFunctions
        }

        return declarationsBySchemaFunctions.keys
    }

    override fun constructors(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<DataConstructor> = emptyList()

        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test
    fun `general dsl schema has types discovered via factory functions`() {
        val schema = schemaFrom(UtilsContainer::class)
        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test

     *
     * @param key the key
     * @param value the value
     */
    void put(K key, V value);

    /**
     * Adds a map entry to the property value.
     *
     * <p>The given provider will be queried when the value of this property is queried.
     * This property will have no value when the given provider has no value.
     *
     * @param key the key

        return self.module(group, name, version);
    }

    @Nullable
    private static String extract(Map<String, CharSequence> map, String key) {
        return map.containsKey(key) ? map.get(key).toString() : null;
    }

    /**
     * Modifies a dependency.
     *
     * @param dependencyNotation dependency to modify
     * @return the modified dependency

fun <V> Map<String, V>.filterKeysByPrefix(prefix: String): Map<String, V?> =
    filterKeys { key -> key.length > prefix.length && key.startsWith(prefix) }


/**
 * Inverts the given map by swapping its keys with their corresponding values and returns the resulting map.
 *
 * If the original map contains duplicate values, the resulting map will map each value to the key associated
 * with the last occurrence of that value in the original map's iteration order.

        for (K item : keys) {
            destination.put(item, keyGenerator.transform(item));
        }
    }

    /**
     * Given a set of keys, derive a set of values and return a map
     */

        if (number == 0) {
            return;
        }

        // See the distributions' respective `compiler.java` files to see the keys used for localization.
        // We are using the following keys:
        //  - count.error and count.error.plural
        //  - count.warn and count.warn.plural
        StringBuilder keyBuilder = new StringBuilder("count.");

|Configurable directory location, whose value is mutable

|`ListProperty<T>`
|List of elements of type `T`

|`SetProperty<T>`
|Set of elements of type `T`

|`MapProperty<K, V>`
|Map of `K` type keys with `V` type values

|`ConfigurableFileCollection`
|A mutable `FileCollection` which represents a collection of file system locations

|`ConfigurableFileTree`

class ThreadLocal {
 public:
  ThreadLocal() : key_(CreateKey()),
                  default_() {}
  explicit ThreadLocal(const T& value) : key_(CreateKey()),
                                         default_(value) {}

  ~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));