* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.coerce;

public interface PropertySetTransformer {
    Object transformValue(Class<?> type, Object value);

                                trySetGetterOnlyProperty(name, value, metaBeanProperty);
                            } else {
                                value = propertySetTransformer.transformValue(metaBeanProperty.getField().getType(), value);
                                metaBeanProperty.getField().setProperty(bean, value);
                            }
                        } else {

        for (Object arg : args) {
            if (arg instanceof CharSequence) {
                return true;
            }
        }
        return false;
    }

    @Override
    public Object transformValue(Class<?> type, Object value) {
        if (value instanceof CharSequence && type.isEnum()) {
            @SuppressWarnings("unchecked") Class<? extends Enum<?>> enumType = (Class<? extends Enum<?>>) type;

        [Long, TestEnum] | [TestEnum.ABC, "abc"] | "two args"
    }

    def "exception thrown when coercing invalid string to enum"() {
        when:
        transformer.transformValue(TestEnum, "invalid")

        then:
        def e = thrown IllegalArgumentException
        TestEnum.values().every { e.message.contains(it.name()) }
    }

    }

    enum SomeEnum {
        A, B, C
    }

    class SomeEnumConverter implements PropertySetTransformer, MethodArgumentsTransformer {
        @Override
        Object transformValue(Class<?> type, Object value) {
            if (type == SomeEnum && value instanceof String) {
                return SomeEnum.valueOf(value as String)
            }

    return Tables.transformValues(original, FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, String> table = HashBasedTable.create();
    table.put(1, "foo", "apple");
    table.put(1, "bar", "banana");
    table.put(3, "foo", "cat");
    return Tables.transformValues(table, FIRST_CHARACTER).columnMap();
  }

    return Tables.transformValues(table, DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);
    table.put("four", 'b', 4);
    return Tables.transformValues(table, DIVIDE_BY_2).column('a');
  }

import java.util.Optional;
import java.util.function.Supplier;

import static com.google.common.collect.ImmutableSortedMap.copyOfSorted;
import static com.google.common.collect.Maps.transformValues;

public class DefaultExecutionHistoryStore implements ExecutionHistoryStore {

    private final IndexedCache<String, PreviousExecutionState> store;

    public DefaultExecutionHistoryStore(

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static com.google.common.collect.ImmutableSortedMap.copyOfSorted;
import static com.google.common.collect.Maps.transformValues;

public class TestExecutionHistoryStore implements ExecutionHistoryStore {

    private final Map<String, PreviousExecutionState> executionHistory = new HashMap<>();

    @Override

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Function;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Test cases for {@link Tables#transformValues}.
 *
 * @author Jared Levy
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public class TablesTransformValuesTest extends AbstractTableTest<Character> {