org.jnosql.artemis.cassandra.column.CassandraColumnEntityConverter Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of cassandra-extension Show documentation
Eclipse JNoSQL mapping layer, Artemis, to Cassandra
There is a newer version: 0.0.9
/*
 *  Copyright (c) 2017 Otávio Santana and others
 *   All rights reserved. This program and the accompanying materials
 *   are made available under the terms of the Eclipse Public License v1.0
 *   and Apache License v2.0 which accompanies this distribution.
 *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
 *
 *   You may elect to redistribute this code under either of these licenses.
 *
 *   Contributors:
 *
 *   Otavio Santana
 */
package org.jnosql.artemis.cassandra.column;


import org.jnosql.artemis.Converters;
import org.jnosql.artemis.column.AbstractColumnEntityConverter;
import org.jnosql.artemis.column.ColumnEntityConverter;
import org.jnosql.artemis.column.ColumnFieldValue;
import org.jnosql.artemis.reflection.ClassRepresentations;
import org.jnosql.artemis.reflection.FieldRepresentation;
import org.jnosql.artemis.reflection.GenericFieldRepresentation;
import org.jnosql.artemis.reflection.Reflections;
import org.jnosql.diana.api.column.Column;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Typed;
import javax.inject.Inject;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.StreamSupport;

@ApplicationScoped
@Typed(CassandraColumnEntityConverter.class)
class CassandraColumnEntityConverter extends AbstractColumnEntityConverter implements ColumnEntityConverter {

    @Inject
    private ClassRepresentations classRepresentations;

    @Inject
    private Reflections reflections;

    @Inject
    private Converters converters;


    @Override
    protected ClassRepresentations getClassRepresentations() {
        return classRepresentations;
    }

    @Override
    protected Reflections getReflections() {
        return reflections;
    }

    @Override
    protected Converters getConverters() {
        return converters;
    }

    @Override
    protected  Consumer feedObject(T instance, List columns, Map fieldsGroupByName) {
        return k -> {
            FieldRepresentation field = fieldsGroupByName.get(k);
            if (Objects.nonNull(field.getNativeField().getAnnotation(UDT.class))) {
                Optional column = columns.stream().filter(c -> c.getName().equals(k)).findFirst();
                setUDTField(instance, column, field);
            } else {
                super.feedObject(instance, columns, fieldsGroupByName).accept(k);
            }
        };
    }

    private  void setUDTField(T instance, Optional column, FieldRepresentation field) {
        if (column.isPresent() && org.jnosql.diana.cassandra.column.UDT.class.isInstance(column.get())) {
            org.jnosql.diana.cassandra.column.UDT udt = org.jnosql.diana.cassandra.column.UDT.class.cast(column.get());
            Object columns = udt.get();
            if (StreamSupport.stream(Iterable.class.cast(columns).spliterator(), false).allMatch(Iterable.class::isInstance)) {
                GenericFieldRepresentation genericField = GenericFieldRepresentation.class.cast(field);
                Collection collection = genericField.getCollectionInstance();
                List> embeddable = (List>) columns;
                for (List columnList : embeddable) {
                    Object element = toEntity(genericField.getElementType(), columnList);
                    collection.add(element);
                }
                reflections.setValue(instance, field.getNativeField(), collection);
            } else {
                Object value = toEntity(field.getNativeField().getType(), (List) columns);
                reflections.setValue(instance, field.getNativeField(), value);
            }
        }
    }

    @Override
    protected ColumnFieldValue to(FieldRepresentation field, Object entityInstance) {
        Object value = reflections.getValue(entityInstance, field.getNativeField());
        UDT annotation = field.getNativeField().getAnnotation(UDT.class);
        if (Objects.isNull(annotation)) {
            return super.to(field, entityInstance);
        } else {
            return new CassandraUDTType(annotation.value(), value, field);
        }
    }
}