From 6ebfdd5c5ea0fa42dca3ecaee69341abc86018fa Mon Sep 17 00:00:00 2001 From: Matthew Adams Date: Thu, 14 Nov 2013 10:00:32 -0600 Subject: [PATCH] formatted sources & added formatting file from spring-data-jpa --- eclipse-formatting.xml | 291 ++++++++++++++++++ .../AbstractCassandraConfiguration.java | 28 +- .../config/CassandraClusterParser.java | 33 +- .../config/CassandraKeyspaceParser.java | 34 +- .../config/CassandraNamespaceHandler.java | 6 +- .../cassandra/config/KeyspaceAttributes.java | 29 +- .../cassandra/config/TableAttributes.java | 6 +- .../convert/AbstractCassandraConverter.java | 16 +- .../cassandra/convert/CassandraConverter.java | 3 +- .../CassandraPropertyValueProvider.java | 23 +- .../convert/MappingCassandraConverter.java | 33 +- .../core/CassandraClusterFactoryBean.java | 73 ++--- .../core/CassandraExceptionTranslator.java | 37 +-- .../data/cassandra/core/CassandraValue.java | 6 +- .../data/cassandra/core/Keyspace.java | 6 +- .../data/cassandra/core/RingMember.java | 9 +- .../CassandraAuthenticationException.java | 6 +- .../CassandraConnectionFailureException.java | 6 +- ...nsufficientReplicasAvailableException.java | 10 +- ...aInvalidConfigurationInQueryException.java | 10 +- .../CassandraInvalidQueryException.java | 6 +- .../CassandraKeyspaceExistsException.java | 9 +- .../CassandraReadTimeoutException.java | 3 +- ...CassandraSchemaElementExistsException.java | 9 +- .../CassandraTableExistsException.java | 9 +- .../CassandraTraceRetrievalException.java | 3 +- .../CassandraTypeMismatchException.java | 3 +- .../CassandraUnauthorizedException.java | 6 +- .../CassandraWriteTimeoutException.java | 3 +- .../data/cassandra/cql/CQLBuilder.java | 2 +- .../BasicCassandraPersistentEntity.java | 18 +- .../BasicCassandraPersistentProperty.java | 63 ++-- .../CachingCassandraPersistentProperty.java | 11 +- .../mapping/CassandraMappingContext.java | 7 +- .../mapping/CassandraPersistentEntity.java | 2 +- .../mapping/CassandraPersistentProperty.java | 12 +- .../mapping/CassandraSimpleTypes.java | 19 +- .../data/cassandra/mapping/Column.java | 2 +- .../data/cassandra/mapping/ColumnId.java | 8 +- .../cassandra/mapping/CompositeRowId.java | 4 +- .../mapping/DataTypeInformation.java | 7 +- .../data/cassandra/mapping/Index.java | 8 +- .../data/cassandra/mapping/Qualify.java | 4 +- .../data/cassandra/mapping/RowId.java | 4 +- .../data/cassandra/mapping/Table.java | 2 +- .../data/cassandra/config/DriverTests.java | 55 ++-- .../CassandraExceptionTranslatorTest.java | 7 +- ...sicCassandraPersistentEntityUnitTests.java | 36 +-- ...cCassandraPersistentPropertyUnitTests.java | 35 +-- .../data/cassandra/test/Comment.java | 14 +- .../data/cassandra/test/LogEntry.java | 16 +- .../data/cassandra/test/Notification.java | 9 +- .../data/cassandra/test/Post.java | 8 +- .../data/cassandra/test/Timeline.java | 17 +- .../data/cassandra/test/User.java | 24 +- 55 files changed, 676 insertions(+), 434 deletions(-) create mode 100644 eclipse-formatting.xml diff --git a/eclipse-formatting.xml b/eclipse-formatting.xml new file mode 100644 index 000000000..c74468778 --- /dev/null +++ b/eclipse-formatting.xml @@ -0,0 +1,291 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/java/org/springframework/data/cassandra/config/AbstractCassandraConfiguration.java b/src/main/java/org/springframework/data/cassandra/config/AbstractCassandraConfiguration.java index 56a2ce9c8..738514b39 100644 --- a/src/main/java/org/springframework/data/cassandra/config/AbstractCassandraConfiguration.java +++ b/src/main/java/org/springframework/data/cassandra/config/AbstractCassandraConfiguration.java @@ -53,7 +53,7 @@ public abstract class AbstractCassandraConfiguration { * @return must not be {@literal null}. */ protected abstract String getKeyspaceName(); - + /** * Return the {@link Cluster} instance to connect to. * @@ -62,10 +62,10 @@ public abstract class AbstractCassandraConfiguration { */ @Bean public abstract Cluster cluster() throws Exception; - + /** - * Creates a {@link Session} to be used by the {@link Keyspace}. Will use the {@link Cluster} instance - * configured in {@link #cluster()}. + * Creates a {@link Session} to be used by the {@link Keyspace}. Will use the {@link Cluster} instance configured in + * {@link #cluster()}. * * @see #cluster() * @see #Keyspace() @@ -77,12 +77,11 @@ public abstract class AbstractCassandraConfiguration { String keyspace = getKeyspaceName(); if (StringUtils.hasText(keyspace)) { return cluster().connect(keyspace); - } - else { + } else { return cluster().connect(); } } - + /** * Creates a {@link Keyspace} to be used by the {@link CassandraTemplate}. Will use the {@link Session} instance * configured in {@link #session()} and {@link CassandraConverter} configured in {@link #converter()}. @@ -96,9 +95,10 @@ public abstract class AbstractCassandraConfiguration { public Keyspace keyspace() throws Exception { return new Keyspace(getKeyspaceName(), session(), converter()); } + /** - * Return the base package to scan for mapped {@link Table}s. Will return the package name of the configuration - * class' (the concrete class, not this one here) by default. So if you have a {@code com.acme.AppConfig} extending + * Return the base package to scan for mapped {@link Table}s. Will return the package name of the configuration class' + * (the concrete class, not this one here) by default. So if you have a {@code com.acme.AppConfig} extending * {@link AbstractCassandraConfiguration} the base package will be considered {@code com.acme} unless the method is * overriden to implement alternate behaviour. * @@ -108,7 +108,7 @@ public abstract class AbstractCassandraConfiguration { protected String getMappingBasePackage() { return getClass().getPackage().getName(); } - + /** * Creates a {@link CassandraTemplate}. * @@ -119,7 +119,7 @@ public abstract class AbstractCassandraConfiguration { public CassandraTemplate cassandraTemplate() throws Exception { return new CassandraTemplate(keyspace()); } - + /** * Return the {@link MappingContext} instance to map Entities to properties. * @@ -130,7 +130,7 @@ public abstract class AbstractCassandraConfiguration { public MappingContext, CassandraPersistentProperty> mappingContext() { return new CassandraMappingContext(); } - + /** * Return the {@link CassandraConverter} instance to convert Rows to Objects. * @@ -141,7 +141,7 @@ public abstract class AbstractCassandraConfiguration { public CassandraConverter converter() { return new MappingCassandraConverter(mappingContext()); } - + /** * Scans the mapping base package for classes annotated with {@link Table}. * @@ -168,5 +168,5 @@ public abstract class AbstractCassandraConfiguration { return initialEntitySet; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/config/CassandraClusterParser.java b/src/main/java/org/springframework/data/cassandra/config/CassandraClusterParser.java index 246071fe8..1718a283f 100644 --- a/src/main/java/org/springframework/data/cassandra/config/CassandraClusterParser.java +++ b/src/main/java/org/springframework/data/cassandra/config/CassandraClusterParser.java @@ -35,7 +35,7 @@ import org.w3c.dom.Element; * @author Alex Shvid */ -public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser { +public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser { @Override protected Class getBeanClass(Element element) { @@ -55,27 +55,26 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser } @Override - protected void doParse(Element element, ParserContext parserContext, - BeanDefinitionBuilder builder) { - + protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { + String contactPoints = element.getAttribute("contactPoints"); if (StringUtils.hasText(contactPoints)) { builder.addPropertyValue("contactPoints", contactPoints); } - + String port = element.getAttribute("port"); if (StringUtils.hasText(port)) { builder.addPropertyValue("port", port); } - + String compression = element.getAttribute("compression"); if (StringUtils.hasText(compression)) { builder.addPropertyValue("compressionType", CompressionType.valueOf(compression)); } - + postProcess(builder, element); } - + @Override protected void postProcess(BeanDefinitionBuilder builder, Element element) { List subElements = DomUtils.getChildElements(element); @@ -86,17 +85,15 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser if ("local-pooling-options".equals(name)) { builder.addPropertyValue("localPoolingOptions", parsePoolingOptions(subElement)); - } - else if ("remote-pooling-options".equals(name)) { + } else if ("remote-pooling-options".equals(name)) { builder.addPropertyValue("remotePoolingOptions", parsePoolingOptions(subElement)); - } - else if ("socket-options".equals(name)) { + } else if ("socket-options".equals(name)) { builder.addPropertyValue("socketOptions", parseSocketOptions(subElement)); } } - - } - + + } + private BeanDefinition parsePoolingOptions(Element element) { BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(PoolingOptionsConfig.class); ParsingUtils.setPropertyValue(defBuilder, element, "min-simultaneous-requests", "minSimultaneousRequests"); @@ -104,8 +101,8 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser ParsingUtils.setPropertyValue(defBuilder, element, "core-connections", "coreConnections"); ParsingUtils.setPropertyValue(defBuilder, element, "max-connections", "maxConnections"); return defBuilder.getBeanDefinition(); - } - + } + private BeanDefinition parseSocketOptions(Element element) { BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(SocketOptionsConfig.class); ParsingUtils.setPropertyValue(defBuilder, element, "connect-timeout-mls", "connectTimeoutMls"); @@ -116,6 +113,6 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser ParsingUtils.setPropertyValue(defBuilder, element, "receive-buffer-size", "receiveBufferSize"); ParsingUtils.setPropertyValue(defBuilder, element, "send-buffer-size", "sendBufferSize"); return defBuilder.getBeanDefinition(); - } + } } diff --git a/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceParser.java b/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceParser.java index 5b34d561d..a9a724452 100644 --- a/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceParser.java +++ b/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceParser.java @@ -36,8 +36,7 @@ import org.w3c.dom.Element; * @author Alex Shvid */ - -public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser { +public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser { @Override protected Class getBeanClass(Element element) { @@ -55,16 +54,15 @@ public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser String id = super.resolveId(element, definition, parserContext); return StringUtils.hasText(id) ? id : BeanNames.CASSANDRA_KEYSPACE; } - + @Override - protected void doParse(Element element, ParserContext parserContext, - BeanDefinitionBuilder builder) { - + protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { + String name = element.getAttribute("name"); if (StringUtils.hasText(name)) { builder.addPropertyValue("keyspace", name); } - + String clusterRef = element.getAttribute("cassandra-cluster-ref"); if (!StringUtils.hasText(clusterRef)) { clusterRef = BeanNames.CASSANDRA_CLUSTER; @@ -78,7 +76,7 @@ public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser postProcess(builder, element); } - + @Override protected void postProcess(BeanDefinitionBuilder builder, Element element) { List subElements = DomUtils.getChildElements(element); @@ -86,28 +84,28 @@ public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser // parse nested elements for (Element subElement : subElements) { String name = subElement.getLocalName(); - + if ("keyspace-attributes".equals(name)) { builder.addPropertyValue("keyspaceAttributes", parseKeyspaceAttributes(subElement)); } } - - } - + + } + private BeanDefinition parseKeyspaceAttributes(Element element) { BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(KeyspaceAttributes.class); ParsingUtils.setPropertyValue(defBuilder, element, "auto", "auto"); ParsingUtils.setPropertyValue(defBuilder, element, "replication-strategy", "replicationStrategy"); ParsingUtils.setPropertyValue(defBuilder, element, "replication-factor", "replicationFactor"); ParsingUtils.setPropertyValue(defBuilder, element, "durable-writes", "durableWrites"); - + List subElements = DomUtils.getChildElements(element); ManagedList tables = new ManagedList(subElements.size()); - + // parse nested elements for (Element subElement : subElements) { String name = subElement.getLocalName(); - + if ("table".equals(name)) { tables.add(parseTable(subElement)); } @@ -115,10 +113,10 @@ public class CassandraKeyspaceParser extends AbstractSimpleBeanDefinitionParser if (!tables.isEmpty()) { defBuilder.addPropertyValue("tables", tables); } - + return defBuilder.getBeanDefinition(); - } - + } + private BeanDefinition parseTable(Element element) { BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(TableAttributes.class); ParsingUtils.setPropertyValue(defBuilder, element, "entity", "entity"); diff --git a/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java b/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java index 9d4bbea9d..a5def8d97 100644 --- a/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java +++ b/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java @@ -26,10 +26,10 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport; public class CassandraNamespaceHandler extends NamespaceHandlerSupport { public void init() { - + registerBeanDefinitionParser("cluster", new CassandraClusterParser()); registerBeanDefinitionParser("keyspace", new CassandraKeyspaceParser()); - + } - + } diff --git a/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java b/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java index f0765d886..748b94726 100644 --- a/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java +++ b/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java @@ -18,9 +18,8 @@ package org.springframework.data.cassandra.config; import java.util.Collection; /** - * Keyspace attributes are used for manipulation around keyspace at the startup. - * Auto property defines the way how to do this. Other attributes used to - * ensure or update keyspace settings. + * Keyspace attributes are used for manipulation around keyspace at the startup. Auto property defines the way how to do + * this. Other attributes used to ensure or update keyspace settings. * * @author Alex Shvid */ @@ -29,34 +28,34 @@ public class KeyspaceAttributes { public static final String DEFAULT_REPLICATION_STRATEGY = "SimpleStrategy"; public static final int DEFAULT_REPLICATION_FACTOR = 1; public static final boolean DEFAULT_DURABLE_WRITES = true; - + /* * auto possible values: * validate: validate the keyspace, makes no changes. - * update: update the keyspace. - * create: creates the keyspace, destroying previous data. - * create-drop: drop the keyspace at the end of the session. + * update: update the keyspace. + * create: creates the keyspace, destroying previous data. + * create-drop: drop the keyspace at the end of the session. */ public static final String AUTO_VALIDATE = "validate"; public static final String AUTO_UPDATE = "update"; public static final String AUTO_CREATE = "create"; public static final String AUTO_CREATE_DROP = "create-drop"; - + private String auto = AUTO_VALIDATE; private String replicationStrategy = DEFAULT_REPLICATION_STRATEGY; private int replicationFactor = DEFAULT_REPLICATION_FACTOR; private boolean durableWrites = DEFAULT_DURABLE_WRITES; private Collection tables; - + public String getAuto() { return auto; } - + public void setAuto(String auto) { this.auto = auto; } - + public boolean isValidate() { return AUTO_VALIDATE.equals(auto); } @@ -76,15 +75,15 @@ public class KeyspaceAttributes { public String getReplicationStrategy() { return replicationStrategy; } - + public void setReplicationStrategy(String replicationStrategy) { this.replicationStrategy = replicationStrategy; } - + public int getReplicationFactor() { return replicationFactor; } - + public void setReplicationFactor(int replicationFactor) { this.replicationFactor = replicationFactor; } @@ -104,5 +103,5 @@ public class KeyspaceAttributes { public void setTables(Collection tables) { this.tables = tables; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/config/TableAttributes.java b/src/main/java/org/springframework/data/cassandra/config/TableAttributes.java index 76f517365..c10e2eefb 100644 --- a/src/main/java/org/springframework/data/cassandra/config/TableAttributes.java +++ b/src/main/java/org/springframework/data/cassandra/config/TableAttributes.java @@ -24,7 +24,7 @@ public class TableAttributes { private String entity; private String name; - + public String getEntity() { return entity; } @@ -32,7 +32,7 @@ public class TableAttributes { public void setEntity(String entity) { this.entity = entity; } - + public String getName() { return name; } @@ -45,5 +45,5 @@ public class TableAttributes { public String toString() { return "TableAttributes [entity=" + entity + "]"; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/convert/AbstractCassandraConverter.java b/src/main/java/org/springframework/data/cassandra/convert/AbstractCassandraConverter.java index 858a930bf..c76b3cdcc 100644 --- a/src/main/java/org/springframework/data/cassandra/convert/AbstractCassandraConverter.java +++ b/src/main/java/org/springframework/data/cassandra/convert/AbstractCassandraConverter.java @@ -22,16 +22,16 @@ import org.springframework.core.convert.support.GenericConversionService; import org.springframework.data.convert.EntityInstantiators; /** - * Base class for {@link CassandraConverter} implementations. Sets up a {@link GenericConversionService} and populates basic - * converters. + * Base class for {@link CassandraConverter} implementations. Sets up a {@link GenericConversionService} and populates + * basic converters. * * @author Alex Shvid */ -public abstract class AbstractCassandraConverter implements CassandraConverter, InitializingBean { +public abstract class AbstractCassandraConverter implements CassandraConverter, InitializingBean { protected final GenericConversionService conversionService; protected EntityInstantiators instantiators = new EntityInstantiators(); - + /** * Creates a new {@link AbstractMongoConverter} using the given {@link GenericConversionService}. * @@ -40,7 +40,7 @@ public abstract class AbstractCassandraConverter implements CassandraConverter, public AbstractCassandraConverter(GenericConversionService conversionService) { this.conversionService = conversionService == null ? new DefaultConversionService() : conversionService; } - + /** * Registers {@link EntityInstantiators} to customize entity instantiation. * @@ -49,7 +49,7 @@ public abstract class AbstractCassandraConverter implements CassandraConverter, public void setInstantiators(EntityInstantiators instantiators) { this.instantiators = instantiators == null ? new EntityInstantiators() : instantiators; } - + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.core.convert.MongoConverter#getConversionService() @@ -57,11 +57,11 @@ public abstract class AbstractCassandraConverter implements CassandraConverter, public ConversionService getConversionService() { return conversionService; } - + /* (non-Javadoc) * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet() */ public void afterPropertiesSet() { } - + } diff --git a/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java b/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java index 72266b0b3..9d840472f 100644 --- a/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java +++ b/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java @@ -26,6 +26,7 @@ import com.datastax.driver.core.Row; * * @author Alex Shvid */ -public interface CassandraConverter extends EntityConverter, CassandraPersistentProperty, Object, Row> { +public interface CassandraConverter extends + EntityConverter, CassandraPersistentProperty, Object, Row> { } diff --git a/src/main/java/org/springframework/data/cassandra/convert/CassandraPropertyValueProvider.java b/src/main/java/org/springframework/data/cassandra/convert/CassandraPropertyValueProvider.java index 96d6c25b9..109086254 100644 --- a/src/main/java/org/springframework/data/cassandra/convert/CassandraPropertyValueProvider.java +++ b/src/main/java/org/springframework/data/cassandra/convert/CassandraPropertyValueProvider.java @@ -35,14 +35,15 @@ import com.datastax.driver.core.Row; * @author Alex Shvid */ public class CassandraPropertyValueProvider implements PropertyValueProvider { - + private static Logger log = LoggerFactory.getLogger(CassandraPropertyValueProvider.class); private final Row source; private final SpELExpressionEvaluator evaluator; - + /** - * Creates a new {@link CassandraPropertyValueProvider} with the given {@link Row} and {@link DefaultSpELExpressionEvaluator}. + * Creates a new {@link CassandraPropertyValueProvider} with the given {@link Row} and + * {@link DefaultSpELExpressionEvaluator}. * * @param source must not be {@literal null}. * @param evaluator must not be {@literal null}. @@ -54,41 +55,41 @@ public class CassandraPropertyValueProvider implements PropertyValueProvider T getPropertyValue(CassandraPersistentProperty property) { - + String expression = property.getSpelExpression(); if (expression != null) { return evaluator.evaluate(expression); } - + String columnName = property.getColumnName(); if (source.isNull(property.getColumnName())) { return null; } DataType columnType = source.getColumnDefinitions().getType(columnName); - + log.info(columnType.getName().name()); - + /* * Dave Webb - Added handler for text since getBytes was throwing * InvalidTypeException when using getBytes on a text column. */ - //TODO Might need to qualify all DataTypes as we encounter them. + // TODO Might need to qualify all DataTypes as we encounter them. if (columnType.equals(DataType.text())) { return (T) source.getString(columnName); } if (columnType.equals(DataType.cint())) { return (T) new Integer(source.getInt(columnName)); } - + ByteBuffer bytes = source.getBytes(columnName); return (T) columnType.deserialize(bytes); } - + } diff --git a/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java b/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java index 3270c9d19..450fc355b 100644 --- a/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java +++ b/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java @@ -46,36 +46,38 @@ import com.datastax.driver.core.Row; public class MappingCassandraConverter extends AbstractCassandraConverter implements ApplicationContextAware { protected static final Logger log = LoggerFactory.getLogger(MappingCassandraConverter.class); - + protected final MappingContext, CassandraPersistentProperty> mappingContext; protected ApplicationContext applicationContext; private SpELContext spELContext; private boolean useFieldAccessOnly = true; - + /** * Creates a new {@link MappingCassandraConverter} given the new {@link MappingContext}. * * @param mappingContext must not be {@literal null}. */ - public MappingCassandraConverter(MappingContext, CassandraPersistentProperty> mappingContext) { + public MappingCassandraConverter( + MappingContext, CassandraPersistentProperty> mappingContext) { super(new DefaultConversionService()); this.mappingContext = mappingContext; this.spELContext = new SpELContext(RowReaderPropertyAccessor.INSTANCE); } - + @SuppressWarnings("unchecked") public R read(Class clazz, Row row) { - + TypeInformation type = ClassTypeInformation.from(clazz); - //TypeInformation typeToUse = typeMapper.readType(row, type); + // TypeInformation typeToUse = typeMapper.readType(row, type); TypeInformation typeToUse = type; Class rawType = typeToUse.getType(); if (Row.class.isAssignableFrom(rawType)) { return (R) row; } - - CassandraPersistentEntity persistentEntity = (CassandraPersistentEntity) mappingContext.getPersistentEntity(typeToUse); + + CassandraPersistentEntity persistentEntity = (CassandraPersistentEntity) mappingContext + .getPersistentEntity(typeToUse); if (persistentEntity == null) { throw new MappingException("No mapping metadata found for " + rawType.getName()); } @@ -99,15 +101,16 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem this.applicationContext = applicationContext; this.spELContext = new SpELContext(this.spELContext, applicationContext); } - + private S read(final CassandraPersistentEntity entity, final Row row) { final DefaultSpELExpressionEvaluator evaluator = new DefaultSpELExpressionEvaluator(row, spELContext); - final PropertyValueProvider propertyProvider = new CassandraPropertyValueProvider(row, evaluator); + final PropertyValueProvider propertyProvider = new CassandraPropertyValueProvider(row, + evaluator); PersistentEntityParameterValueProvider parameterProvider = new PersistentEntityParameterValueProvider( entity, propertyProvider, null); - + EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity); S instance = instantiator.createInstance(entity, parameterProvider); @@ -129,7 +132,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem wrapper.setProperty(prop, obj, useFieldAccessOnly); } }); - + return result; } @@ -142,16 +145,14 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem */ @Override public void write(Object source, Row sink) { - + /* * There is no concept of passing a Row into Cassandra for Writing. * This must be done with Query * * See the CQLUtils. */ - + } - - } diff --git a/src/main/java/org/springframework/data/cassandra/core/CassandraClusterFactoryBean.java b/src/main/java/org/springframework/data/cassandra/core/CassandraClusterFactoryBean.java index 26b5341b7..456bfd5b0 100644 --- a/src/main/java/org/springframework/data/cassandra/core/CassandraClusterFactoryBean.java +++ b/src/main/java/org/springframework/data/cassandra/core/CassandraClusterFactoryBean.java @@ -41,34 +41,34 @@ import com.datastax.driver.core.policies.RetryPolicy; * @author Alex Shvid */ -public class CassandraClusterFactoryBean implements FactoryBean, - InitializingBean, DisposableBean, PersistenceExceptionTranslator { +public class CassandraClusterFactoryBean implements FactoryBean, InitializingBean, DisposableBean, + PersistenceExceptionTranslator { private static final int DEFAULT_PORT = 9042; - + private Cluster cluster; - + private String contactPoints; private int port = DEFAULT_PORT; private CompressionType compressionType; - + private PoolingOptionsConfig localPoolingOptions; private PoolingOptionsConfig remotePoolingOptions; private SocketOptionsConfig socketOptions; - + private AuthProvider authProvider; private LoadBalancingPolicy loadBalancingPolicy; private ReconnectionPolicy reconnectionPolicy; private RetryPolicy retryPolicy; - + private boolean metricsEnabled = true; - + private final PersistenceExceptionTranslator exceptionTranslator = new CassandraExceptionTranslator(); public Cluster getObject() throws Exception { return cluster; } - + /* * (non-Javadoc) * @see org.springframework.beans.factory.FactoryBean#getObjectType() @@ -84,7 +84,7 @@ public class CassandraClusterFactoryBean implements FactoryBean, public boolean isSingleton() { return true; } - + /* * (non-Javadoc) * @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException) @@ -92,22 +92,21 @@ public class CassandraClusterFactoryBean implements FactoryBean, public DataAccessException translateExceptionIfPossible(RuntimeException ex) { return exceptionTranslator.translateExceptionIfPossible(ex); } - + /* * (non-Javadoc) * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet() */ public void afterPropertiesSet() throws Exception { - + if (!StringUtils.hasText(contactPoints)) { - throw new IllegalArgumentException( - "at least one server is required"); + throw new IllegalArgumentException("at least one server is required"); } - + Cluster.Builder builder = Cluster.builder(); builder.addContactPoints(StringUtils.commaDelimitedListToStringArray(contactPoints)).withPort(port); - + if (compressionType != null) { builder.withCompression(convertCompressionType(compressionType)); } @@ -123,33 +122,33 @@ public class CassandraClusterFactoryBean implements FactoryBean, if (socketOptions != null) { builder.withSocketOptions(configSocketOptions(socketOptions)); } - + if (authProvider != null) { builder.withAuthProvider(authProvider); } - + if (loadBalancingPolicy != null) { builder.withLoadBalancingPolicy(loadBalancingPolicy); } - + if (reconnectionPolicy != null) { builder.withReconnectionPolicy(reconnectionPolicy); } - + if (retryPolicy != null) { builder.withRetryPolicy(retryPolicy); } - + if (!metricsEnabled) { builder.withoutMetrics(); - } - + } + Cluster cluster = builder.build(); - + // initialize property this.cluster = cluster; } - + /* * (non-Javadoc) * @see org.springframework.beans.factory.DisposableBean#destroy() @@ -169,7 +168,7 @@ public class CassandraClusterFactoryBean implements FactoryBean, public void setCompressionType(CompressionType compressionType) { this.compressionType = compressionType; } - + public void setLocalPoolingOptions(PoolingOptionsConfig localPoolingOptions) { this.localPoolingOptions = localPoolingOptions; } @@ -185,7 +184,7 @@ public class CassandraClusterFactoryBean implements FactoryBean, public void setAuthProvider(AuthProvider authProvider) { this.authProvider = authProvider; } - + public void setLoadBalancingPolicy(LoadBalancingPolicy loadBalancingPolicy) { this.loadBalancingPolicy = loadBalancingPolicy; } @@ -203,23 +202,25 @@ public class CassandraClusterFactoryBean implements FactoryBean, } private static Compression convertCompressionType(CompressionType type) { - switch(type) { + switch (type) { case NONE: - return Compression.NONE; + return Compression.NONE; case SNAPPY: return Compression.SNAPPY; } throw new IllegalArgumentException("unknown compression type " + type); } - + private static PoolingOptions configPoolingOptions(HostDistance hostDistance, PoolingOptionsConfig config) { PoolingOptions poolingOptions = new PoolingOptions(); if (config.getMinSimultaneousRequests() != null) { - poolingOptions.setMinSimultaneousRequestsPerConnectionThreshold(hostDistance, config.getMinSimultaneousRequests()); + poolingOptions + .setMinSimultaneousRequestsPerConnectionThreshold(hostDistance, config.getMinSimultaneousRequests()); } if (config.getMaxSimultaneousRequests() != null) { - poolingOptions.setMaxSimultaneousRequestsPerConnectionThreshold(hostDistance, config.getMaxSimultaneousRequests()); + poolingOptions + .setMaxSimultaneousRequestsPerConnectionThreshold(hostDistance, config.getMaxSimultaneousRequests()); } if (config.getCoreConnections() != null) { poolingOptions.setCoreConnectionsPerHost(hostDistance, config.getCoreConnections()); @@ -227,13 +228,13 @@ public class CassandraClusterFactoryBean implements FactoryBean, if (config.getMaxConnections() != null) { poolingOptions.setMaxConnectionsPerHost(hostDistance, config.getMaxConnections()); } - + return poolingOptions; } - + private static SocketOptions configSocketOptions(SocketOptionsConfig config) { SocketOptions socketOptions = new SocketOptions(); - + if (config.getConnectTimeoutMls() != null) { socketOptions.setConnectTimeoutMillis(config.getConnectTimeoutMls()); } @@ -255,7 +256,7 @@ public class CassandraClusterFactoryBean implements FactoryBean, if (config.getSendBufferSize() != null) { socketOptions.setSendBufferSize(config.getSendBufferSize()); } - + return socketOptions; } } diff --git a/src/main/java/org/springframework/data/cassandra/core/CassandraExceptionTranslator.java b/src/main/java/org/springframework/data/cassandra/core/CassandraExceptionTranslator.java index 973375b3c..588e024ee 100644 --- a/src/main/java/org/springframework/data/cassandra/core/CassandraExceptionTranslator.java +++ b/src/main/java/org/springframework/data/cassandra/core/CassandraExceptionTranslator.java @@ -52,18 +52,15 @@ import com.datastax.driver.core.exceptions.UnavailableException; import com.datastax.driver.core.exceptions.WriteTimeoutException; /** - * Simple {@link PersistenceExceptionTranslator} for Cassandra. Convert the - * given runtime exception to an appropriate exception from the - * {@code org.springframework.dao} hierarchy. Return {@literal null} if no - * translation is appropriate: any other exception may have resulted from user - * code, and should not be translated. + * Simple {@link PersistenceExceptionTranslator} for Cassandra. Convert the given runtime exception to an appropriate + * exception from the {@code org.springframework.dao} hierarchy. Return {@literal null} if no translation is + * appropriate: any other exception may have resulted from user code, and should not be translated. * * @author Alex Shvid * @author Matthew T. Adams */ -public class CassandraExceptionTranslator implements - PersistenceExceptionTranslator { +public class CassandraExceptionTranslator implements PersistenceExceptionTranslator { /* * (non-Javadoc) @@ -81,8 +78,7 @@ public class CassandraExceptionTranslator implements // superclass would match before the subclass! if (x instanceof AuthenticationException) { - return new CassandraAuthenticationException( - ((AuthenticationException) x).getHost(), x.getMessage(), x); + return new CassandraAuthenticationException(((AuthenticationException) x).getHost(), x.getMessage(), x); } if (x instanceof DriverInternalError) { return new CassandraInternalException(x.getMessage(), x); @@ -91,40 +87,31 @@ public class CassandraExceptionTranslator implements return new CassandraTypeMismatchException(x.getMessage(), x); } if (x instanceof NoHostAvailableException) { - return new CassandraConnectionFailureException( - ((NoHostAvailableException) x).getErrors(), x.getMessage(), - x); + return new CassandraConnectionFailureException(((NoHostAvailableException) x).getErrors(), x.getMessage(), x); } if (x instanceof ReadTimeoutException) { - return new CassandraReadTimeoutException( - ((ReadTimeoutException) x).wasDataRetrieved(), - x.getMessage(), x); + return new CassandraReadTimeoutException(((ReadTimeoutException) x).wasDataRetrieved(), x.getMessage(), x); } if (x instanceof WriteTimeoutException) { WriteType writeType = ((WriteTimeoutException) x).getWriteType(); - return new CassandraWriteTimeoutException(writeType == null ? null - : writeType.name(), x.getMessage(), x); + return new CassandraWriteTimeoutException(writeType == null ? null : writeType.name(), x.getMessage(), x); } if (x instanceof TruncateException) { return new CassandraTruncateException(x.getMessage(), x); } if (x instanceof UnavailableException) { UnavailableException ux = (UnavailableException) x; - return new CassandraInsufficientReplicasAvailableException( - ux.getRequiredReplicas(), ux.getAliveReplicas(), + return new CassandraInsufficientReplicasAvailableException(ux.getRequiredReplicas(), ux.getAliveReplicas(), x.getMessage(), x); } if (x instanceof AlreadyExistsException) { AlreadyExistsException aex = (AlreadyExistsException) x; - return aex.wasTableCreation() ? new CassandraTableExistsException( - aex.getTable(), x.getMessage(), x) - : new CassandraKeyspaceExistsException(aex.getKeyspace(), - x.getMessage(), x); + return aex.wasTableCreation() ? new CassandraTableExistsException(aex.getTable(), x.getMessage(), x) + : new CassandraKeyspaceExistsException(aex.getKeyspace(), x.getMessage(), x); } if (x instanceof InvalidConfigurationInQueryException) { - return new CassandraInvalidConfigurationInQueryException( - x.getMessage(), x); + return new CassandraInvalidConfigurationInQueryException(x.getMessage(), x); } if (x instanceof InvalidQueryException) { return new CassandraInvalidQueryException(x.getMessage(), x); diff --git a/src/main/java/org/springframework/data/cassandra/core/CassandraValue.java b/src/main/java/org/springframework/data/cassandra/core/CassandraValue.java index 489d6ed54..8d165908d 100644 --- a/src/main/java/org/springframework/data/cassandra/core/CassandraValue.java +++ b/src/main/java/org/springframework/data/cassandra/core/CassandraValue.java @@ -25,10 +25,10 @@ import com.datastax.driver.core.DataType; * @author Alex Shvid */ public class CassandraValue { - + private final ByteBuffer value; private final DataType type; - + public CassandraValue(ByteBuffer value, DataType type) { this.value = value; this.type = type; @@ -41,5 +41,5 @@ public class CassandraValue { public DataType getType() { return type; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/core/Keyspace.java b/src/main/java/org/springframework/data/cassandra/core/Keyspace.java index b3b0be483..66e200ed8 100644 --- a/src/main/java/org/springframework/data/cassandra/core/Keyspace.java +++ b/src/main/java/org/springframework/data/cassandra/core/Keyspace.java @@ -20,7 +20,7 @@ import org.springframework.data.cassandra.convert.CassandraConverter; import com.datastax.driver.core.Session; /** - * Simple Cassandra Keyspace object + * Simple Cassandra Keyspace object * * @author Alex Shvid */ @@ -29,7 +29,7 @@ public class Keyspace { private final String keyspace; private final Session session; private final CassandraConverter cassandraConverter; - + /** * Constructor used for a basic keyspace configuration * @@ -42,7 +42,7 @@ public class Keyspace { this.session = session; this.cassandraConverter = cassandraConverter; } - + public String getKeyspace() { return keyspace; } diff --git a/src/main/java/org/springframework/data/cassandra/core/RingMember.java b/src/main/java/org/springframework/data/cassandra/core/RingMember.java index e985fd391..829a8d1ab 100644 --- a/src/main/java/org/springframework/data/cassandra/core/RingMember.java +++ b/src/main/java/org/springframework/data/cassandra/core/RingMember.java @@ -21,12 +21,12 @@ import com.datastax.driver.core.Host; /** * @author David Webb - * + * */ public final class RingMember implements Serializable { private static final long serialVersionUID = 1345346346L; - + /* * Ring attributes */ @@ -34,8 +34,9 @@ public final class RingMember implements Serializable { public final String address; public final String DC; public final String rack; - //public final String status; - //public final String state; + + // public final String status; + // public final String state; public RingMember(Host h) { this.hostName = h.getAddress().getHostName(); diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraAuthenticationException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraAuthenticationException.java index 833cafcb2..19aa8c3be 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraAuthenticationException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraAuthenticationException.java @@ -25,15 +25,13 @@ import org.springframework.dao.PermissionDeniedDataAccessException; * * @author Matthew T. Adams */ -public class CassandraAuthenticationException extends - PermissionDeniedDataAccessException { +public class CassandraAuthenticationException extends PermissionDeniedDataAccessException { private static final long serialVersionUID = 8556304586797273927L; private InetAddress host; - public CassandraAuthenticationException(InetAddress host, String msg, - Throwable cause) { + public CassandraAuthenticationException(InetAddress host, String msg, Throwable cause) { super(msg, cause); this.host = host; } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraConnectionFailureException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraConnectionFailureException.java index ff48523e0..a23facb20 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraConnectionFailureException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraConnectionFailureException.java @@ -28,15 +28,13 @@ import org.springframework.dao.DataAccessResourceFailureException; * * @author Matthew T. Adams */ -public class CassandraConnectionFailureException extends - DataAccessResourceFailureException { +public class CassandraConnectionFailureException extends DataAccessResourceFailureException { private static final long serialVersionUID = 6299912054261646552L; private final Map messagesByHost = new HashMap(); - public CassandraConnectionFailureException( - Map messagesByHost, String msg, Throwable cause) { + public CassandraConnectionFailureException(Map messagesByHost, String msg, Throwable cause) { super(msg, cause); this.messagesByHost.putAll(messagesByHost); } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInsufficientReplicasAvailableException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInsufficientReplicasAvailableException.java index bcd7c70bb..8b30e8596 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInsufficientReplicasAvailableException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInsufficientReplicasAvailableException.java @@ -19,13 +19,11 @@ package org.springframework.data.cassandra.core.exceptions; import org.springframework.dao.TransientDataAccessException; /** - * Spring data access exception for Cassandra when insufficient replicas are - * available for a given consistency level. + * Spring data access exception for Cassandra when insufficient replicas are available for a given consistency level. * * @author Matthew T. Adams */ -public class CassandraInsufficientReplicasAvailableException extends - TransientDataAccessException { +public class CassandraInsufficientReplicasAvailableException extends TransientDataAccessException { private static final long serialVersionUID = 6415130674604814905L; @@ -36,8 +34,8 @@ public class CassandraInsufficientReplicasAvailableException extends super(msg); } - public CassandraInsufficientReplicasAvailableException(int numberRequired, - int numberAlive, String msg, Throwable cause) { + public CassandraInsufficientReplicasAvailableException(int numberRequired, int numberAlive, String msg, + Throwable cause) { super(msg, cause); this.numberRequired = numberRequired; this.numberAlive = numberAlive; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidConfigurationInQueryException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidConfigurationInQueryException.java index 00c206f42..5fabd5745 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidConfigurationInQueryException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidConfigurationInQueryException.java @@ -19,13 +19,12 @@ package org.springframework.data.cassandra.core.exceptions; import org.springframework.dao.InvalidDataAccessApiUsageException; /** - * Spring data access exception for a Cassandra query that is syntactically - * correct but has an invalid configuration clause. + * Spring data access exception for a Cassandra query that is syntactically correct but has an invalid configuration + * clause. * * @author Matthew T. Adams */ -public class CassandraInvalidConfigurationInQueryException extends - InvalidDataAccessApiUsageException { +public class CassandraInvalidConfigurationInQueryException extends InvalidDataAccessApiUsageException { private static final long serialVersionUID = 4594321191806182918L; @@ -33,8 +32,7 @@ public class CassandraInvalidConfigurationInQueryException extends super(msg); } - public CassandraInvalidConfigurationInQueryException(String msg, - Throwable cause) { + public CassandraInvalidConfigurationInQueryException(String msg, Throwable cause) { super(msg, cause); } } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidQueryException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidQueryException.java index 8f517f652..1591e61b3 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidQueryException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraInvalidQueryException.java @@ -19,13 +19,11 @@ package org.springframework.data.cassandra.core.exceptions; import org.springframework.dao.InvalidDataAccessApiUsageException; /** - * Spring data access exception for a Cassandra query that's syntactically - * correct but invalid. + * Spring data access exception for a Cassandra query that's syntactically correct but invalid. * * @author Matthew T. Adams */ -public class CassandraInvalidQueryException extends - InvalidDataAccessApiUsageException { +public class CassandraInvalidQueryException extends InvalidDataAccessApiUsageException { private static final long serialVersionUID = 4594321191806182918L; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraKeyspaceExistsException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraKeyspaceExistsException.java index edc32dd80..a6fa952a2 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraKeyspaceExistsException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraKeyspaceExistsException.java @@ -17,18 +17,15 @@ package org.springframework.data.cassandra.core.exceptions; /** - * Spring data access exception for Cassandra when a keyspace being created - * already exists. + * Spring data access exception for Cassandra when a keyspace being created already exists. * * @author Matthew T. Adams */ -public class CassandraKeyspaceExistsException extends - CassandraSchemaElementExistsException { +public class CassandraKeyspaceExistsException extends CassandraSchemaElementExistsException { private static final long serialVersionUID = 6032967419751410352L; - public CassandraKeyspaceExistsException(String keyspaceName, String msg, - Throwable cause) { + public CassandraKeyspaceExistsException(String keyspaceName, String msg, Throwable cause) { super(keyspaceName, ElementType.KEYSPACE, msg, cause); } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraReadTimeoutException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraReadTimeoutException.java index 76b2d48a0..da695656e 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraReadTimeoutException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraReadTimeoutException.java @@ -29,8 +29,7 @@ public class CassandraReadTimeoutException extends QueryTimeoutException { private boolean wasDataReceived; - public CassandraReadTimeoutException(boolean wasDataReceived, String msg, - Throwable cause) { + public CassandraReadTimeoutException(boolean wasDataReceived, String msg, Throwable cause) { super(msg); this.wasDataReceived = wasDataReceived; } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraSchemaElementExistsException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraSchemaElementExistsException.java index c8b261065..a94c37eee 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraSchemaElementExistsException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraSchemaElementExistsException.java @@ -19,13 +19,11 @@ package org.springframework.data.cassandra.core.exceptions; import org.springframework.dao.NonTransientDataAccessException; /** - * Spring data access exception for when Cassandra schema element being created - * already exists. + * Spring data access exception for when Cassandra schema element being created already exists. * * @author Matthew T. Adams */ -public class CassandraSchemaElementExistsException extends - NonTransientDataAccessException { +public class CassandraSchemaElementExistsException extends NonTransientDataAccessException { private static final long serialVersionUID = 7798361273692300162L; @@ -36,8 +34,7 @@ public class CassandraSchemaElementExistsException extends private String elementName; private ElementType elementType; - public CassandraSchemaElementExistsException(String elementName, - ElementType elementType, String msg, Throwable cause) { + public CassandraSchemaElementExistsException(String elementName, ElementType elementType, String msg, Throwable cause) { super(msg, cause); this.elementName = elementName; this.elementType = elementType; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTableExistsException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTableExistsException.java index 1b9307e5c..a8f0fb13d 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTableExistsException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTableExistsException.java @@ -17,18 +17,15 @@ package org.springframework.data.cassandra.core.exceptions; /** - * Spring data access exception for when a Cassandra table being created already - * exists. + * Spring data access exception for when a Cassandra table being created already exists. * * @author Matthew T. Adams */ -public class CassandraTableExistsException extends - CassandraSchemaElementExistsException { +public class CassandraTableExistsException extends CassandraSchemaElementExistsException { private static final long serialVersionUID = 6032967419751410352L; - public CassandraTableExistsException(String tableName, String msg, - Throwable cause) { + public CassandraTableExistsException(String tableName, String msg, Throwable cause) { super(tableName, ElementType.TABLE, msg, cause); } diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTraceRetrievalException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTraceRetrievalException.java index d8cf40f85..456db7495 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTraceRetrievalException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTraceRetrievalException.java @@ -23,8 +23,7 @@ import org.springframework.dao.TransientDataAccessException; * * @author Matthew T. Adams */ -public class CassandraTraceRetrievalException extends - TransientDataAccessException { +public class CassandraTraceRetrievalException extends TransientDataAccessException { private static final long serialVersionUID = -3163557220324700239L; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTypeMismatchException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTypeMismatchException.java index 3a6847831..bc8c08e1c 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTypeMismatchException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraTypeMismatchException.java @@ -23,8 +23,7 @@ import org.springframework.dao.TypeMismatchDataAccessException; * * @author Matthew T. Adams */ -public class CassandraTypeMismatchException extends - TypeMismatchDataAccessException { +public class CassandraTypeMismatchException extends TypeMismatchDataAccessException { private static final long serialVersionUID = -7420058975444905629L; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraUnauthorizedException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraUnauthorizedException.java index ad981702d..74da9ef2a 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraUnauthorizedException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraUnauthorizedException.java @@ -19,13 +19,11 @@ package org.springframework.data.cassandra.core.exceptions; import org.springframework.dao.PermissionDeniedDataAccessException; /** - * Spring data access exception for when access to a Cassandra element is - * denied. + * Spring data access exception for when access to a Cassandra element is denied. * * @author Matthew T. Adams */ -public class CassandraUnauthorizedException extends - PermissionDeniedDataAccessException { +public class CassandraUnauthorizedException extends PermissionDeniedDataAccessException { private static final long serialVersionUID = 4618185356687726647L; diff --git a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraWriteTimeoutException.java b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraWriteTimeoutException.java index e35474b68..d7ab05240 100644 --- a/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraWriteTimeoutException.java +++ b/src/main/java/org/springframework/data/cassandra/core/exceptions/CassandraWriteTimeoutException.java @@ -29,8 +29,7 @@ public class CassandraWriteTimeoutException extends QueryTimeoutException { private String writeType; - public CassandraWriteTimeoutException(String writeType, String msg, - Throwable cause) { + public CassandraWriteTimeoutException(String writeType, String msg, Throwable cause) { super(msg, cause); this.writeType = writeType; } diff --git a/src/main/java/org/springframework/data/cassandra/cql/CQLBuilder.java b/src/main/java/org/springframework/data/cassandra/cql/CQLBuilder.java index 622b20805..29ad8a7a4 100644 --- a/src/main/java/org/springframework/data/cassandra/cql/CQLBuilder.java +++ b/src/main/java/org/springframework/data/cassandra/cql/CQLBuilder.java @@ -5,5 +5,5 @@ public abstract class CQLBuilder { public static CreateTable createTable(String tableName) { return null; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java b/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java index b296beee7..bfaa039bb 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java @@ -38,15 +38,15 @@ import org.springframework.util.StringUtils; * @author Alex Shvid */ public class BasicCassandraPersistentEntity extends BasicPersistentEntity implements -CassandraPersistentEntity, ApplicationContextAware { + CassandraPersistentEntity, ApplicationContextAware { private final String table; private final SpelExpressionParser parser; private final StandardEvaluationContext context; - + /** - * Creates a new {@link BasicCassandraPersistentEntity} with the given {@link TypeInformation}. Will default the - * table name to the entities simple type name. + * Creates a new {@link BasicCassandraPersistentEntity} with the given {@link TypeInformation}. Will default the table + * name to the entities simple type name. * * @param typeInformation */ @@ -67,7 +67,7 @@ CassandraPersistentEntity, ApplicationContextAware { this.table = fallback; } } - + /* * (non-Javadoc) * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext) @@ -78,7 +78,7 @@ CassandraPersistentEntity, ApplicationContextAware { context.setBeanResolver(new BeanFactoryResolver(applicationContext)); context.setRootObject(applicationContext); } - + /** * Returns the table the entity shall be persisted to. * @@ -88,7 +88,7 @@ CassandraPersistentEntity, ApplicationContextAware { Expression expression = parser.parseExpression(table, ParserContext.TEMPLATE_EXPRESSION); return expression.getValue(context, String.class); } - + /** * {@link Comparator} implementation inspecting the {@link CassandraPersistentProperty}'s order. * @@ -113,8 +113,8 @@ CassandraPersistentEntity, ApplicationContextAware { } return o1.getColumnName().compareTo(o2.getColumnName()); - + } } - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java b/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java index d66959b5b..c77b95204 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java @@ -34,9 +34,9 @@ import com.datastax.driver.core.DataType; * * @author Alex Shvid */ -public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentProperty implements -CassandraPersistentProperty { - +public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentProperty + implements CassandraPersistentProperty { + /** * Creates a new {@link BasicCassandraPersistentProperty}. * @@ -49,7 +49,7 @@ CassandraPersistentProperty { CassandraPersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { super(field, propertyDescriptor, owner, simpleTypeHolder); } - + /** * Also considers fields that has a RowId annotation. * @@ -63,16 +63,16 @@ CassandraPersistentProperty { return getField().isAnnotationPresent(RowId.class); } - + /** - * For dynamic tables returns true if property value is used as column name. + * For dynamic tables returns true if property value is used as column name. * * @return */ public boolean isColumnId() { return getField().isAnnotationPresent(ColumnId.class); } - + /** * Returns the column name to be used to store the value of the property inside the Cassandra. * @@ -82,7 +82,7 @@ CassandraPersistentProperty { Column annotation = getField().getAnnotation(Column.class); return annotation != null && StringUtils.hasText(annotation.value()) ? annotation.value() : field.getName(); } - + /** * Returns the data type information if exists. * @@ -96,21 +96,23 @@ CassandraPersistentProperty { if (isMap()) { List> args = getTypeInformation().getTypeArguments(); ensureTypeArguments(args.size(), 2); - return DataType.map(autodetectPrimitiveType(args.get(0).getType()), autodetectPrimitiveType(args.get(1).getType())); + return DataType.map(autodetectPrimitiveType(args.get(0).getType()), + autodetectPrimitiveType(args.get(1).getType())); } if (isCollectionLike()) { List> args = getTypeInformation().getTypeArguments(); ensureTypeArguments(args.size(), 1); if (Set.class.isAssignableFrom(getType())) { - return DataType.set(autodetectPrimitiveType(args.get(0).getType())); - } - else if (List.class.isAssignableFrom(getType())) { - return DataType.list(autodetectPrimitiveType(args.get(0).getType())); + return DataType.set(autodetectPrimitiveType(args.get(0).getType())); + } else if (List.class.isAssignableFrom(getType())) { + return DataType.list(autodetectPrimitiveType(args.get(0).getType())); } } DataType dataType = CassandraSimpleTypes.autodetectPrimitive(this.getType()); if (dataType == null) { - throw new InvalidDataAccessApiUsageException("only primitive types and Set,List,Map collections are allowed, unknown type for property '" + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); + throw new InvalidDataAccessApiUsageException( + "only primitive types and Set,List,Map collections are allowed, unknown type for property '" + this.getName() + + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); } return dataType; } @@ -118,10 +120,10 @@ CassandraPersistentProperty { private DataType qualifyAnnotatedType(Qualify annotation) { DataType.Name type = annotation.type(); if (type.isCollection()) { - switch(type) { + switch (type) { case MAP: ensureTypeArguments(annotation.typeArguments().length, 2); - return DataType.map(resolvePrimitiveType(annotation.typeArguments()[0]), + return DataType.map(resolvePrimitiveType(annotation.typeArguments()[0]), resolvePrimitiveType(annotation.typeArguments()[1])); case LIST: ensureTypeArguments(annotation.typeArguments().length, 1); @@ -130,23 +132,23 @@ CassandraPersistentProperty { ensureTypeArguments(annotation.typeArguments().length, 1); return DataType.set(resolvePrimitiveType(annotation.typeArguments()[0])); default: - throw new InvalidDataAccessApiUsageException("unknown collection DataType for property '" + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); + throw new InvalidDataAccessApiUsageException("unknown collection DataType for property '" + this.getName() + + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); } - } - else { + } else { return CassandraSimpleTypes.resolvePrimitive(type); } } - + /** - * Returns true if the property has secondary index on this column. + * Returns true if the property has secondary index on this column. * * @return */ public boolean isIndexed() { return getField().isAnnotationPresent(Index.class); } - + /* * (non-Javadoc) * @see org.springframework.data.mapping.model.AbstractPersistentProperty#createAssociation() @@ -159,7 +161,9 @@ CassandraPersistentProperty { DataType resolvePrimitiveType(DataType.Name typeName) { DataType dataType = CassandraSimpleTypes.resolvePrimitive(typeName); if (dataType == null) { - throw new InvalidDataAccessApiUsageException("only primitive types are allowed inside collections for the property '" + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); + throw new InvalidDataAccessApiUsageException( + "only primitive types are allowed inside collections for the property '" + this.getName() + "' type is '" + + this.getType() + "' in the entity " + this.getOwner().getName()); } return dataType; } @@ -167,17 +171,18 @@ CassandraPersistentProperty { DataType autodetectPrimitiveType(Class javaType) { DataType dataType = CassandraSimpleTypes.autodetectPrimitive(javaType); if (dataType == null) { - throw new InvalidDataAccessApiUsageException("only primitive types are allowed inside collections for the property '" + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); + throw new InvalidDataAccessApiUsageException( + "only primitive types are allowed inside collections for the property '" + this.getName() + "' type is '" + + this.getType() + "' in the entity " + this.getOwner().getName()); } return dataType; } void ensureTypeArguments(int args, int expected) { if (args != expected) { - throw new InvalidDataAccessApiUsageException("expected " + expected + " of typed arguments for the property '" + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); - } + throw new InvalidDataAccessApiUsageException("expected " + expected + " of typed arguments for the property '" + + this.getName() + "' type is '" + this.getType() + "' in the entity " + this.getOwner().getName()); + } } - -} - \ No newline at end of file +} diff --git a/src/main/java/org/springframework/data/cassandra/mapping/CachingCassandraPersistentProperty.java b/src/main/java/org/springframework/data/cassandra/mapping/CachingCassandraPersistentProperty.java index c46987e24..0e59b5318 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/CachingCassandraPersistentProperty.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/CachingCassandraPersistentProperty.java @@ -20,7 +20,6 @@ import java.lang.reflect.Field; import org.springframework.data.mapping.model.SimpleTypeHolder; - /** * {@link CassandraPersistentProperty} caching access to {@link #isIdProperty()} and {@link #getColumnName()}. * @@ -32,7 +31,7 @@ public class CachingCassandraPersistentProperty extends BasicCassandraPersistent private Boolean isColumnId; private String columnName; private Boolean isIndexed; - + /** * Creates a new {@link CachingCassandraPersistentProperty}. * @@ -45,7 +44,7 @@ public class CachingCassandraPersistentProperty extends BasicCassandraPersistent CassandraPersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { super(field, propertyDescriptor, owner, simpleTypeHolder); } - + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.mapping.BasicCassandraPersistentProperty#isIdProperty() @@ -59,7 +58,7 @@ public class CachingCassandraPersistentProperty extends BasicCassandraPersistent return this.isIdProperty; } - + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.mapping.BasicCassandraPersistentProperty#isColumnId() @@ -73,7 +72,7 @@ public class CachingCassandraPersistentProperty extends BasicCassandraPersistent return this.isColumnId; } - + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.mapping.BasicCassandraPersistentProperty#getFieldName() @@ -87,7 +86,7 @@ public class CachingCassandraPersistentProperty extends BasicCassandraPersistent return this.columnName; } - + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.mapping.BasicCassandraPersistentProperty#isIndexed() diff --git a/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java b/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java index 5c1b14ea6..ec59a044c 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java @@ -32,8 +32,9 @@ import org.springframework.data.util.TypeInformation; * * @author Alex Shvid */ -public class CassandraMappingContext extends AbstractMappingContext, CassandraPersistentProperty> -implements ApplicationContextAware { +public class CassandraMappingContext extends + AbstractMappingContext, CassandraPersistentProperty> implements + ApplicationContextAware { private ApplicationContext context; @@ -80,5 +81,5 @@ implements ApplicationContextAware { this.context = applicationContext; super.setApplicationContext(applicationContext); } - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/CassandraPersistentEntity.java b/src/main/java/org/springframework/data/cassandra/mapping/CassandraPersistentEntity.java index a6f9f5fac..1c39ed007 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/CassandraPersistentEntity.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/CassandraPersistentEntity.java @@ -30,5 +30,5 @@ public interface CassandraPersistentEntity extends PersistentEntity { /** - * For dynamic tables returns true if property value is used as column name. + * For dynamic tables returns true if property value is used as column name. * * @return */ boolean isColumnId(); - + /** * Returns the name of the field a property is persisted to. * * @return */ String getColumnName(); - + /** * Returns the data type. * * @return */ DataType getDataType(); - + /** - * Returns true if the property has secondary index on this column. + * Returns true if the property has secondary index on this column. * * @return */ boolean isIndexed(); - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/CassandraSimpleTypes.java b/src/main/java/org/springframework/data/cassandra/mapping/CassandraSimpleTypes.java index c62c15e7c..b03537275 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/CassandraSimpleTypes.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/CassandraSimpleTypes.java @@ -38,11 +38,11 @@ public class CassandraSimpleTypes { private static final Map, Class> primitiveWrapperTypeMap = new HashMap, Class>(8); private static final Map, DataType> javaClassToDataType = new HashMap, DataType>(); - + private static final Map nameToDataType = new HashMap(); - + static { - + primitiveWrapperTypeMap.put(Boolean.class, boolean.class); primitiveWrapperTypeMap.put(Byte.class, byte.class); primitiveWrapperTypeMap.put(Character.class, char.class); @@ -51,7 +51,7 @@ public class CassandraSimpleTypes { primitiveWrapperTypeMap.put(Integer.class, int.class); primitiveWrapperTypeMap.put(Long.class, long.class); primitiveWrapperTypeMap.put(Short.class, short.class); - + Set> simpleTypes = new HashSet>(); for (DataType dataType : DataType.allPrimitiveTypes()) { simpleTypes.add(dataType.asJavaClass()); @@ -72,26 +72,27 @@ public class CassandraSimpleTypes { private CassandraSimpleTypes() { } - + public static DataType resolvePrimitive(DataType.Name name) { return nameToDataType.get(name); } - + public static DataType autodetectPrimitive(Class javaClass) { return javaClassToDataType.get(javaClass); } - + public static DataType.Name[] convertPrimitiveTypeArguments(List> arguments) { DataType.Name[] result = new DataType.Name[arguments.size()]; for (int i = 0; i != result.length; ++i) { TypeInformation type = arguments.get(i); DataType dataType = autodetectPrimitive(type.getType()); if (dataType == null) { - throw new InvalidDataAccessApiUsageException("not found appropriate primitive DataType for type = '" + type.getType()); + throw new InvalidDataAccessApiUsageException("not found appropriate primitive DataType for type = '" + + type.getType()); } result[i] = dataType.getName(); } return result; } - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/Column.java b/src/main/java/org/springframework/data/cassandra/mapping/Column.java index a450afa36..eb87656d5 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/Column.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/Column.java @@ -19,5 +19,5 @@ public @interface Column { * @return */ String value() default ""; - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/ColumnId.java b/src/main/java/org/springframework/data/cassandra/mapping/ColumnId.java index af58f2bc5..36a9aa3d9 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/ColumnId.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/ColumnId.java @@ -21,13 +21,13 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** - * Uses in dynamic tables where column names are values of this field. - * Usually it is a Date/Time field or UUIDTime field. + * Uses in dynamic tables where column names are values of this field. Usually it is a Date/Time field or UUIDTime + * field. * * @author Alex Shvid */ -@Retention(value=RetentionPolicy.RUNTIME) -@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.ANNOTATION_TYPE}) +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = { ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE }) public @interface ColumnId { } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/CompositeRowId.java b/src/main/java/org/springframework/data/cassandra/mapping/CompositeRowId.java index 954131563..2ceca4e1d 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/CompositeRowId.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/CompositeRowId.java @@ -23,8 +23,8 @@ import java.lang.annotation.Target; import org.springframework.data.annotation.Id; /** - * Identifies composite row ID in the Cassandra table that contains several - * fields. Same as @org.springframework.data.annotation.Id + * Identifies composite row ID in the Cassandra table that contains several fields. Same as + * @org.springframework.data.annotation.Id * * Example: * diff --git a/src/main/java/org/springframework/data/cassandra/mapping/DataTypeInformation.java b/src/main/java/org/springframework/data/cassandra/mapping/DataTypeInformation.java index ca3c776f4..51e71f5d0 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/DataTypeInformation.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/DataTypeInformation.java @@ -24,8 +24,8 @@ import com.datastax.driver.core.DataType; */ public class DataTypeInformation { - public static DataType.Name[] EMPTY_ATTRIBUTES = {}; - + public static DataType.Name[] EMPTY_ATTRIBUTES = {}; + private DataType.Name typeName; private DataType.Name[] typeAttributes; @@ -57,8 +57,7 @@ public class DataTypeInformation { public String toCQL() { if (typeAttributes.length == 0) { return typeName.name(); - } - else { + } else { StringBuilder str = new StringBuilder(); str.append(typeName.name()); str.append('<'); diff --git a/src/main/java/org/springframework/data/cassandra/mapping/Index.java b/src/main/java/org/springframework/data/cassandra/mapping/Index.java index b1571f7c2..bc60d8121 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/Index.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/Index.java @@ -21,15 +21,15 @@ import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** - * Identifies a secondary index in the table. Usually it is a field with common dublicate values - * for the hole table. such as city, place, educationType, state flags ant etc. + * Identifies a secondary index in the table. Usually it is a field with common dublicate values for the hole table. + * such as city, place, educationType, state flags ant etc. * * Using unique fields is not common and has overhead, such as email, username and etc. * * @author Alex Shvid */ -@Retention(value=RetentionPolicy.RUNTIME) -@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.ANNOTATION_TYPE}) +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = { ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE }) public @interface Index { } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/Qualify.java b/src/main/java/org/springframework/data/cassandra/mapping/Qualify.java index 456bf4d99..5c6772762 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/Qualify.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/Qualify.java @@ -31,7 +31,7 @@ import com.datastax.driver.core.DataType; public @interface Qualify { DataType.Name type(); - + DataType.Name[] typeArguments() default {}; - + } diff --git a/src/main/java/org/springframework/data/cassandra/mapping/RowId.java b/src/main/java/org/springframework/data/cassandra/mapping/RowId.java index 0619add42..d335937a6 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/RowId.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/RowId.java @@ -27,8 +27,8 @@ import org.springframework.data.annotation.Id; * * @author Alex Shvid */ -@Retention(value=RetentionPolicy.RUNTIME) -@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.ANNOTATION_TYPE}) +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = { ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE }) @Id public @interface RowId { diff --git a/src/main/java/org/springframework/data/cassandra/mapping/Table.java b/src/main/java/org/springframework/data/cassandra/mapping/Table.java index 62a067935..c875102af 100644 --- a/src/main/java/org/springframework/data/cassandra/mapping/Table.java +++ b/src/main/java/org/springframework/data/cassandra/mapping/Table.java @@ -35,5 +35,5 @@ import org.springframework.data.annotation.Persistent; public @interface Table { String name() default ""; - + } diff --git a/src/test/java/org/springframework/data/cassandra/config/DriverTests.java b/src/test/java/org/springframework/data/cassandra/config/DriverTests.java index a84d4476e..b338b0161 100644 --- a/src/test/java/org/springframework/data/cassandra/config/DriverTests.java +++ b/src/test/java/org/springframework/data/cassandra/config/DriverTests.java @@ -15,37 +15,36 @@ import com.datastax.driver.core.Session; public class DriverTests { - @BeforeClass - public static void startCassandra() - throws IOException, TTransportException, ConfigurationException, InterruptedException { - EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); - } - + @BeforeClass + public static void startCassandra() throws IOException, TTransportException, ConfigurationException, + InterruptedException { + EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); + } + @Test public void test() throws Exception { - + Cluster.Builder builder = Cluster.builder().addContactPoint("127.0.0.1"); - //builder.withCompression(ProtocolOptions.Compression.SNAPPY); - - Cluster cluster = builder.build(); - - Session session = cluster.connect(); - - session.shutdown(); - - cluster.shutdown(); - - - } - - @After - public void clearCassandra() { - EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); - } + // builder.withCompression(ProtocolOptions.Compression.SNAPPY); - @AfterClass - public static void stopCassandra() { - EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); - } + Cluster cluster = builder.build(); + + Session session = cluster.connect(); + + session.shutdown(); + + cluster.shutdown(); + + } + + @After + public void clearCassandra() { + EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); + } + + @AfterClass + public static void stopCassandra() { + EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); + } } diff --git a/src/test/java/org/springframework/data/cassandra/core/CassandraExceptionTranslatorTest.java b/src/test/java/org/springframework/data/cassandra/core/CassandraExceptionTranslatorTest.java index 3ee016a97..414d9961c 100644 --- a/src/test/java/org/springframework/data/cassandra/core/CassandraExceptionTranslatorTest.java +++ b/src/test/java/org/springframework/data/cassandra/core/CassandraExceptionTranslatorTest.java @@ -32,8 +32,7 @@ public class CassandraExceptionTranslatorTest { CassandraTableExistsException x = (CassandraTableExistsException) dax; assertEquals(table, x.getTableName()); assertEquals(x.getTableName(), x.getElementName()); - assertEquals(CassandraSchemaElementExistsException.ElementType.TABLE, - x.getElementType()); + assertEquals(CassandraSchemaElementExistsException.ElementType.TABLE, x.getElementType()); assertEquals(cx, x.getCause()); } @@ -49,9 +48,7 @@ public class CassandraExceptionTranslatorTest { CassandraKeyspaceExistsException x = (CassandraKeyspaceExistsException) dax; assertEquals(keyspace, x.getKeyspaceName()); assertEquals(x.getKeyspaceName(), x.getElementName()); - assertEquals( - CassandraSchemaElementExistsException.ElementType.KEYSPACE, - x.getElementType()); + assertEquals(CassandraSchemaElementExistsException.ElementType.KEYSPACE, x.getElementType()); assertEquals(cx, x.getCause()); } diff --git a/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntityUnitTests.java b/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntityUnitTests.java index cb23477d2..f23c53005 100644 --- a/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntityUnitTests.java +++ b/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntityUnitTests.java @@ -34,7 +34,6 @@ import org.mockito.runners.MockitoJUnitRunner; import org.springframework.context.ApplicationContext; import org.springframework.data.util.ClassTypeInformation; - /** * Unit tests for {@link BasicCassandraPersistentEntity}. * @@ -43,15 +42,14 @@ import org.springframework.data.util.ClassTypeInformation; @RunWith(MockitoJUnitRunner.class) public class BasicCassandraPersistentEntityUnitTests { - @Mock ApplicationContext context; - - @BeforeClass - public static void startCassandra() - throws IOException, TTransportException, ConfigurationException, InterruptedException { - EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); - } + + @BeforeClass + public static void startCassandra() throws IOException, TTransportException, ConfigurationException, + InterruptedException { + EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); + } @Test public void subclassInheritsAtDocumentAnnotation() { @@ -84,16 +82,16 @@ public class BasicCassandraPersistentEntityUnitTests { assertThat(entity.getTable(), is("user_line")); } - - @After - public void clearCassandra() { - EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); - } - @AfterClass - public static void stopCassandra() { - EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); - } + @After + public void clearCassandra() { + EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); + } + + @AfterClass + public static void stopCassandra() { + EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); + } @Table(name = "messages") class Message { @@ -115,12 +113,12 @@ public class BasicCassandraPersistentEntityUnitTests { } class MappingBean { - + String userLine; public String getUserLine() { return userLine; } } - + } diff --git a/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentPropertyUnitTests.java b/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentPropertyUnitTests.java index a938d6d80..71e247744 100644 --- a/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentPropertyUnitTests.java +++ b/src/test/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentPropertyUnitTests.java @@ -35,7 +35,6 @@ import org.springframework.data.mapping.model.SimpleTypeHolder; import org.springframework.data.util.ClassTypeInformation; import org.springframework.util.ReflectionUtils; - /** * Unit test for {@link BasicCassandraPersistentProperty}. * @@ -44,12 +43,12 @@ import org.springframework.util.ReflectionUtils; public class BasicCassandraPersistentPropertyUnitTests { CassandraPersistentEntity entity; - - @BeforeClass - public static void startCassandra() - throws IOException, TTransportException, ConfigurationException, InterruptedException { - EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); - } + + @BeforeClass + public static void startCassandra() throws IOException, TTransportException, ConfigurationException, + InterruptedException { + EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml"); + } @Before public void setup() { @@ -82,16 +81,16 @@ public class BasicCassandraPersistentPropertyUnitTests { assertThat(property.isColumnId(), is(true)); } - @After - public void clearCassandra() { - EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); - } + @After + public void clearCassandra() { + EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); + } + + @AfterClass + public static void stopCassandra() { + EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); + } - @AfterClass - public static void stopCassandra() { - EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); - } - private CassandraPersistentProperty getPropertyFor(Field field) { return new BasicCassandraPersistentProperty(field, null, entity, new SimpleTypeHolder()); } @@ -103,10 +102,10 @@ public class BasicCassandraPersistentPropertyUnitTests { @ColumnId Date time; - + @Column("message") String text; } - + } diff --git a/src/test/java/org/springframework/data/cassandra/test/Comment.java b/src/test/java/org/springframework/data/cassandra/test/Comment.java index 7077baa4e..bd7712703 100644 --- a/src/test/java/org/springframework/data/cassandra/test/Comment.java +++ b/src/test/java/org/springframework/data/cassandra/test/Comment.java @@ -26,12 +26,10 @@ import org.springframework.data.cassandra.mapping.Table; import com.datastax.driver.core.DataType; /** - * This is an example of dynamic table that creates each time new column - * with Post timestamp annotated by @ColumnId. + * This is an example of dynamic table that creates each time new column with Post timestamp annotated by @ColumnId. * - * It is possible to use a static table for posts and identify them by PostId(UUID), - * but in this case we need to use MapReduce for Big Data to find posts for - * particular user, so it is better to have index (userId) -> index (post time) + * It is possible to use a static table for posts and identify them by PostId(UUID), but in this case we need to use + * MapReduce for Big Data to find posts for particular user, so it is better to have index (userId) -> index (post time) * architecture. It helps a lot to build eventually a search index for the particular user. * * @author Alex Shvid @@ -49,12 +47,12 @@ public class Comment { * Column ID */ @ColumnId - @Qualify(type=DataType.Name.TIMESTAMP) + @Qualify(type = DataType.Name.TIMESTAMP) private Date time; private String text; - - @Qualify(type=DataType.Name.SET, typeArguments={DataType.Name.TEXT}) + + @Qualify(type = DataType.Name.SET, typeArguments = { DataType.Name.TEXT }) private Set likes; /* diff --git a/src/test/java/org/springframework/data/cassandra/test/LogEntry.java b/src/test/java/org/springframework/data/cassandra/test/LogEntry.java index 5297e8460..700c3b084 100644 --- a/src/test/java/org/springframework/data/cassandra/test/LogEntry.java +++ b/src/test/java/org/springframework/data/cassandra/test/LogEntry.java @@ -23,15 +23,15 @@ import org.springframework.data.cassandra.mapping.RowId; import org.springframework.data.cassandra.mapping.Table; /** - * This is an example of the Users statis table, where all fields are columns - * in Cassandra row. Some fields can be Set,List,Map like emails. + * This is an example of the Users statis table, where all fields are columns in Cassandra row. Some fields can be + * Set,List,Map like emails. * - * User contains base information related for separate user, like - * names, additional information, emails, following users, friends. + * User contains base information related for separate user, like names, additional information, emails, following + * users, friends. * * @author Alex Shvid */ -@Table(name="log_entry") +@Table(name = "log_entry") public class LogEntry { /* @@ -39,9 +39,9 @@ public class LogEntry { */ @RowId private Date logDate; - + private String hostname; - + private String logData; /** @@ -85,5 +85,5 @@ public class LogEntry { public void setLogData(String logData) { this.logData = logData; } - + } \ No newline at end of file diff --git a/src/test/java/org/springframework/data/cassandra/test/Notification.java b/src/test/java/org/springframework/data/cassandra/test/Notification.java index d9bb678cd..b0c17ed19 100644 --- a/src/test/java/org/springframework/data/cassandra/test/Notification.java +++ b/src/test/java/org/springframework/data/cassandra/test/Notification.java @@ -23,12 +23,11 @@ import org.springframework.data.cassandra.mapping.Index; import org.springframework.data.cassandra.mapping.Table; /** - * This is an example of dynamic table that creates each time new column - * with Notification timestamp annotated by @ColumnId. + * This is an example of dynamic table that creates each time new column with Notification timestamp annotated by + * @ColumnId. * - * By default it is active Notification until user deactivate it. - * This table uses index on the field active to access in WHERE cause only - * for active notifications. + * By default it is active Notification until user deactivate it. This table uses index on the field active to access in + * WHERE cause only for active notifications. * * @author Alex Shvid */ diff --git a/src/test/java/org/springframework/data/cassandra/test/Post.java b/src/test/java/org/springframework/data/cassandra/test/Post.java index 951aba196..c02dcf689 100644 --- a/src/test/java/org/springframework/data/cassandra/test/Post.java +++ b/src/test/java/org/springframework/data/cassandra/test/Post.java @@ -24,12 +24,10 @@ import org.springframework.data.cassandra.mapping.ColumnId; import org.springframework.data.cassandra.mapping.Table; /** - * This is an example of dynamic table that creates each time new column - * with Post timestamp annotated by @ColumnId. + * This is an example of dynamic table that creates each time new column with Post timestamp annotated by @ColumnId. * - * It is possible to use a static table for posts and identify them by PostId(UUID), - * but in this case we need to use MapReduce for Big Data to find posts for - * particular user, so it is better to have index (userId) -> index (post time) + * It is possible to use a static table for posts and identify them by PostId(UUID), but in this case we need to use + * MapReduce for Big Data to find posts for particular user, so it is better to have index (userId) -> index (post time) * architecture. It helps a lot to build eventually a search index for the particular user. * * @author Alex Shvid diff --git a/src/test/java/org/springframework/data/cassandra/test/Timeline.java b/src/test/java/org/springframework/data/cassandra/test/Timeline.java index 5ac7df462..53a1ebffc 100644 --- a/src/test/java/org/springframework/data/cassandra/test/Timeline.java +++ b/src/test/java/org/springframework/data/cassandra/test/Timeline.java @@ -22,17 +22,15 @@ import org.springframework.data.cassandra.mapping.ColumnId; import org.springframework.data.cassandra.mapping.Table; /** - * This is an example of the users timeline dynamic table, where all columns - * are dynamically created by @ColumnId field value. The rest fields are places - * in Cassandra value. + * This is an example of the users timeline dynamic table, where all columns are dynamically created by @ColumnId field + * value. The rest fields are places in Cassandra value. * - * Timeline entity is used to store user's status updates that it follows in the site. - * Timeline always ordered by @ColumnId field and we can retrieve last top status - * updates by using limits. + * Timeline entity is used to store user's status updates that it follows in the site. Timeline always ordered by @ColumnId + * field and we can retrieve last top status updates by using limits. * * @author Alex Shvid */ -@Table(name="timeline") +@Table(name = "timeline") public class Timeline { /* @@ -40,13 +38,13 @@ public class Timeline { */ @Id private String username; - + /* * Column ID */ @ColumnId private Date time; - + /* * Reference to the post by author and postUID */ @@ -85,5 +83,4 @@ public class Timeline { this.postTime = postTime; } - } diff --git a/src/test/java/org/springframework/data/cassandra/test/User.java b/src/test/java/org/springframework/data/cassandra/test/User.java index a8a62a3d8..fd091cf73 100644 --- a/src/test/java/org/springframework/data/cassandra/test/User.java +++ b/src/test/java/org/springframework/data/cassandra/test/User.java @@ -22,15 +22,15 @@ import org.springframework.data.cassandra.mapping.Index; import org.springframework.data.cassandra.mapping.Table; /** - * This is an example of the Users statis table, where all fields are columns - * in Cassandra row. Some fields can be Set,List,Map like emails. + * This is an example of the Users statis table, where all fields are columns in Cassandra row. Some fields can be + * Set,List,Map like emails. * - * User contains base information related for separate user, like - * names, additional information, emails, following users, friends. + * User contains base information related for separate user, like names, additional information, emails, following + * users, friends. * * @author Alex Shvid */ -@Table(name="users") +@Table(name = "users") public class User { /* @@ -38,40 +38,40 @@ public class User { */ @Id private String username; - + /* * Public information */ private String firstName; private String lastName; - + /* * Secondary index, used only on fields with common information, * not effective on email, username */ @Index private String place; - + /* * User emails */ private Set emails; - + /* * Password */ private String password; - + /* * Age */ private int age; - + /* * Following other users in userline */ private Set following; - + /* * Friends of the user */