fr.sii.ogham.sms.builder.cloudhopper

Class MessageSplitterBuilder

java.lang.Object

fr.sii.ogham.core.fluent.AbstractParent<CloudhopperBuilder>

fr.sii.ogham.sms.builder.cloudhopper.MessageSplitterBuilder

All Implemented Interfaces:

Builder<MessageSplitter>, Parent<CloudhopperBuilder>

public class MessageSplitterBuilder
extends AbstractParent<CloudhopperBuilder>
implements Builder<MessageSplitter>

Configures how Cloudhopper will split messages.

The splitter will check if the whole message can fit in a single segment. If not the splitter will split the whole message in several segments with a header to indicate splitting information such as number of segments, reference number and current segment number.

Encoder configured using CloudhopperBuilder.encoder() is used to encode each segment.

If automatic guessing of best standard encoder is enabled for Encoder (using encoder().autoGuess(true)), and message splitting is enabled, then standard message splitting is configured such as:

• If GSM 7-bit encoder is enabled, GsmMessageSplitter is used to split messages that support this encoding. If whole message can fit in a single segment of 160 characters. Longer message is split into segments of either 153 characters or 152 characters (depending on reference number generation, see ReferenceNumberGenerator)
• If GSM 8-bit encoder is enabled, GsmMessageSplitter is used to split messages that support this encoding. If whole message can fit in a single segment of 140 characters. Longer message is split into segments of either 134 characters or 133 characters (depending on reference number generation, see ReferenceNumberGenerator)
• If UCS-2 encoder is enabled, GsmMessageSplitter is used to split messages that support this encoding. If whole message can fit in a single segment of 70 characters. Longer message is split into segments of either 67 characters or 66 characters (depending on reference number generation, see ReferenceNumberGenerator)

Each registered splitter uses the same priority as associated Encoder. If you don't want standard message splitting based on supported Encoders, you can either disable message splitting or provide a custom splitter with higher priority.

This builder allows to configure:

• Enable/disable message splitting
• Provide a custom split strategy
• Choose strategy for reference number generation

 
 .splitter()
   .enable()
     .properties("${ogham.sms.cloudhopper.split.enable}", "${ogham.sms.split.enable}")
     .devaultValue(true)
     .and()
   .customSplitter(new MyCustomSplitter(), 100000)
   .referenceNumber()
     .random()
     .random(new Random())
     .generator(new MyCustomReferenceNumberGenerator())
 
 

Author:

Aurélien Baudet

Field Summary

Fields inherited from class fr.sii.ogham.core.fluent.AbstractParent

parent

Constructor Summary

Constructors

Constructor and Description
MessageSplitterBuilder(CloudhopperBuilder parent, BuildContext buildContext, ReadableEncoderBuilder encoderBuilder) Initializes the builder with a parent builder.

Method Summary

Modifier and Type	Method and Description
MessageSplitter	build() Instantiate and configures the instance.
MessageSplitterBuilder	customSplitter(MessageSplitter splitter) Register a custom splitter strategy.
MessageSplitterBuilder	customSplitter(MessageSplitter splitter, int priority) Register a custom splitter strategy in the chain of splitters.
ConfigurationValueBuilder<MessageSplitterBuilder,Boolean>	enable() Enable/disable message splitting.
MessageSplitterBuilder	enable(Boolean enable) Enable/disable message splitting.
ReferenceNumberGeneratorBuilder	referenceNumber() Configures how Cloudhopper should generate a reference number.

Methods inherited from class fr.sii.ogham.core.fluent.AbstractParent

and

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MessageSplitterBuilder

public MessageSplitterBuilder(CloudhopperBuilder parent,
                              BuildContext buildContext,
                              ReadableEncoderBuilder encoderBuilder)

Initializes the builder with a parent builder. The parent builder is used when calling AbstractParent.and() method. The EnvironmentBuilder is used to evaluate properties when build() method is called.

Parameters:

parent - the parent builder

buildContext - for registering instances and property evaluation

encoderBuilder - the encoder builder that is used to configure standard message splitting based on encoding charset

Method Detail

enable

public MessageSplitterBuilder enable(Boolean enable)

Enable/disable message splitting.

The value set using this method takes precedence over any property and default value configured using enable().

 .enable(false)
 .enable()
   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")
   .defaultValue(true)
 

 .enable(false)
 .enable()
   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")
   .defaultValue(true)
 

In both cases, enable(false) is used.

If this method is called several times, only the last value is used.

If null value is set, it is like not setting a value at all. The property/default value configuration is applied.

Parameters:

enable - enable or disable message splitting

Returns:

this instance for fluent chaining

enable

public ConfigurationValueBuilder<MessageSplitterBuilder,Boolean> enable()

Enable/disable message splitting.

This method is mainly used by Configurers to register some property keys and/or a default value. The aim is to let developer be able to externalize its configuration (using system properties, configuration file or anything else). If the developer doesn't configure any value for the registered properties, the default value is used (if set).

 .enable()
   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")
   .defaultValue(true)
 

Non-null value set using enable(Boolean) takes precedence over property values and default value.

 .enable(false)
 .enable()
   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")
   .defaultValue(true)
 

The value false is used regardless of the value of the properties and default value.

See ConfigurationValueBuilder for more information.

Returns:

the builder to configure property keys/default value

referenceNumber

public ReferenceNumberGeneratorBuilder referenceNumber()

Configures how Cloudhopper should generate a reference number.

Reference number is used to identify segments that belong to the same message. Every segment of the split message must have the same reference number.

This builder allows to configure:

• Enable random generation strategy
• Customize random generation by providing a custom Random
• Provide a custom generator

 
   .referenceNumber()
     .random()
     .random(new Random())
     .generator(new MyCustomReferenceNumberGenerator())
 
 

Returns:

the builder to configure reference number generation

See Also:

ReferenceNumberGenerator

customSplitter

public MessageSplitterBuilder customSplitter(MessageSplitter splitter)

Register a custom splitter strategy.

Using this method totally disable all other features. Only the provided splitter is used.

If this method is called several times, only the last one is used.

If null value is provided, then custom splitting is disabled.

Parameters:

splitter - the splitter to use

Returns:

this instance for fluent chaining

customSplitter

public MessageSplitterBuilder customSplitter(MessageSplitter splitter,
                                             int priority)

Register a custom splitter strategy in the chain of splitters.

It is possible to register several custom splitters.

The priority is used to indicate in which order the custom splitter must be applied in the chain.

If the custom splitter implements SupportingSplitter, then the splitter can indicate if it is able to handle to message to split. If the splitter can't handle the message, then the next splitter is tried.

If the custom splitter doesn't implement SupportingSplitter, then the splitter is considered as able to handle the message. Splitting is used with this splitter. So if such splitter is registered with a higher priority than others, no other splitter will be tried.

Parameters:

splitter - the splitter to register

priority - the associated priority (greater value means higher priority)

Returns:

this instance for fluent chaining

build

public MessageSplitter build()

Description copied from interface: Builder

Instantiate and configures the instance.

Specified by:

build in interface Builder<MessageSplitter>

Returns:

The built instance