The final version for now is:
| Code Block |
|---|
|
interface IByteStateConverter
{
IIdentifiable ConvertFromByteArray(byte[] array);
byte[] ConvertToByteArray(IIdentifiable stateId);
}
public interface IManageState
{
/// <summary>
/// Store the linkable component's current State
/// </summary>
/// <returns>Object that identifies the stored state.</returns>
ObjectIIdentifiable KeepCurrentState();
/// <summary>
/// Restores the state identified by the parameter stateID. If the state identifier identified by
/// stateID is not known by the linkable component an exceptionInvalidOperationException should be trown.
/// </summary>
/// <param name="stateID">Object that identifies the state to be restored.</param>
void RestoreState(ObjectIIdentifiable stateIDstateId);
/// <summary>
/// Clears a state from the linkable component's memory. If the state identifier identified by
/// stateID is not known by the linkable component an exception should be trown.
/// </summary>
/// <param name="stateID">Object that identifies the state to be cleared.</param>
void ClearState(ObjectIIdentifiable stateIDstateId);
}
interface IPersistentState
{
/// <summary>
/// Transform the state of a component instance into an array of bytes
/// </summary>
/// <param name="state">The state to be turned into a byte array</param>
/// <returns></returns>
byte[] makePersistent(object state);
/// <summary>
/// Read the state of a component instance from an array of bytes
/// </summary>
/// <param name="persistentState">Byte array containing the state</param>
/// <returns></returns>
object readPersistentState(byte[] persistentState);
}
|
Suggestion: rename IPersistentState into IState and make it to be byte[]-convertible, the following interface demonstrate the idea:
Suggestion for IState and IManageState refactoring in Java version:
| Code Block |
|---|
|
public interface IByteStateConverter {
IIdentifiable convertFromByteArray(byte[] array);
byte[] convertToByteArray(IIdentifiable stateId);
}
public interface IManageState {
public IIdentifiable keepCurrentState();
public void restoreState(IState state);
public void clearState(IState state);
}
|
Previous version:
| Code Block |
|---|
|
|
| Code Block |
|---|
| java | java |
interface IState: IIdentifiable, IDescribable
{
}
interface IByteStateConverter
{
IState ConvertFromByteArray(byte[] array);
byte[] ConvertToByteArray(IState state);
}
public interface IManageState
{
/// <summary>
/// Store the linkable component's current State
/// </summary>
/// <returns>Object that identifies the stored state.</returns>
IStateObject KeepCurrentState();
/// <summary>
/// Restores the state identified by the parameter stateID. If the state identifier identified by
/// stateID is not known by the linkable component an exception should be trown.
/// </summary>
/// <param name="stateID">Object that identifies the state to be restored.</param>
void RestoreState(IStateObject statestateID);
/// <summary>
/// Clears a state from the linkable component's memory. If the state identifier identified by
/// stateID is not known by the linkable component an exception should be trown.
/// </summary>
/// <param name="stateID">Object that identifies the state to be cleared.</param>
void ClearState(IStateObject statestateID);
}
interface IPersistentState
{
/// <summary>
/// All available states created using KeepCurrentState() Transform the state of a component instance into an array of bytes
/// </summary>
IEnumerable<IState>/// AvailableStates { get; }
}
|
Suggestion for IState and IManageState refactoring in Java version:
| Code Block |
|---|
| java | java |
public interface IIdentifiable {
public long getId();
}
public interface IState extends IIdentifiable {
public byte[] toByteArray();
}
public interface IManageState {
// linkable component state management
public IState keepCurrentState();
public void restoreState(IState state);
public void clearState(IState state);
// TODO: decide if states should be publically visible
public Collection<IState> getStates();
// factory method to revive state
public IState createStateFromByteArray(byte[] bytes);
<param name="state">The state to be turned into a byte array</param>
/// <returns></returns>
byte[] makePersistent(object state);
/// <summary>
/// Read the state of a component instance from an array of bytes
/// </summary>
/// <param name="persistentState">Byte array containing the state</param>
/// <returns></returns>
object readPersistentState(byte[] persistentState);
}
|