/// <summary>
/// <para>Reads an object from the store.</para>
/// </summary>
/// <typeparam name="T">
/// <para>The type of the object.</para>
/// </typeparam>
/// <param name="keySpace">
/// <para>The key space of the entry.</para>
/// </param>
/// <param name="key">
/// <para>The key of the entry.</para>
/// </param>
/// <param name="creator">
/// <para>Delegate that provides an empty instance for
/// deserialization.</para>
/// </param>
/// <returns>
/// <para>A <see cref="StorageEntry{T}"/> containing the entry.</para>
/// </returns>
public StorageEntry <T> Get <T>(DataBuffer keySpace, StorageKey key, Func <T> creator)
{
if (Storage.StreamsData)
{
var data = Storage.GetBuffer(keySpace, key);
if (data == null)
{
return(StorageEntry <T> .NotFound);
}
DataBuffer buffer = data;
using (var stream = new MemoryStream(data, false))
{
return(GetCore(buffer, stream, creator()));
}
}
else
{
using (var item = StreamPool.GetItem())
{
DataBuffer buffer;
var stream = GetStream(item, keySpace, key, out buffer);
if (stream == null)
{
return(StorageEntry <T> .NotFound);
}
return(GetCore(buffer, stream, creator()));
}
}
}
/// <summary>
/// <para>Deletes an object from the store by version.</para>
/// </summary>
/// <param name="keySpace">
/// <para>The key space of the entry.</para>
/// </param>
/// <param name="key">
/// <para>The key of the entry.</para>
/// </param>
/// <param name="updated">
/// <para>The last updated <see cref="DateTime"/> of the version to be deleted. If the entry's last updated date is not newer than this value, then the entry will be deleted, otherwise not.</para>
/// </param>
/// <returns>
/// <para>
/// <see langword="true"/> if the entry was deleted; otherwise <see langword="false"/>. The entry is deleted if it existed prior and was as old or older than <paramref name="updated"/>.</para>
/// </returns>
public bool DeleteVersion(DataBuffer keySpace, StorageKey key, DateTime updated)
{
using (var item = StreamPool.GetItem())
{
var stream = item.Item;
if (stream.Capacity < sizeof(long))
{
stream.Capacity = sizeof(long);
}
var buffer = GetReadBuffer(stream);
buffer = buffer.Restrict(sizeof(long));
var len = Storage.Get(keySpace, key, sizeof(long), buffer);
if (len < 0)
{
return(false);
}
var seg = buffer.ByteArraySegmentValue;
var ticks = BitConverter.ToInt64(seg.Array, seg.Offset);
var entryUpdated = new DateTime(ticks);
if (entryUpdated <= updated)
{
return(Storage.Delete(keySpace, key));
}
return(false);
}
}
public override void RunOnAwake()
{
base.RunOnAwake();
ResourceStream newStream = StreamPool.getStream(initialValue, initialState, initialColor);
this.animColor = newStream._streamColor;
this.Stream = newStream;
this.PassStream();
}
public override void ManageStream()
{
if (this.Stream.GetState != this.StreamprocessingType)
{
StreamPool.returnStream(this.Stream);
this.ChangeState = runningState.incorrectInput;
return;
}
// myAnimator.setAnimState(this);
this.PassStream();
}
/// <summary>
/// <para>Writes an object to the store.</para>
/// </summary>
/// <typeparam name="T">
/// <para>The type of the object.</para>
/// </typeparam>
/// <param name="keySpace">
/// <para>The key space of the entry.</para>
/// </param>
/// <param name="key">
/// <para>The key of the entry.</para>
/// </param>
/// <param name="entry">
/// <para>The entry to write.</para>
/// </param>
public void Put <T>(DataBuffer keySpace, StorageKey key, StorageEntry <T> entry)
{
AddKeySpaceInfo <T>(keySpace);
using (var item = StreamPool.GetItem())
{
var stream = item.Item;
stream.Write(BitConverter.GetBytes(entry.Expires.Ticks), 0, sizeof(long));
stream.Write(BitConverter.GetBytes(entry.Updated.Ticks), 0, sizeof(long));
Serializer.Serialize(stream, entry.Instance);
Storage.Put(keySpace, key, GetWriteBuffer(stream));
}
}
public void StopRunning()
{
animState = runningState.notRunning;
myState = runningState.notRunning;
//animColor = streamColor.notSet;
if (myStream != null)
{
StreamPool.returnStream(myStream);
myStream = null;
}
ManageAnimator();
}
/// <summary>
/// Creates instance of EJDB.
/// </summary>
/// <param name="library"></param>
public Database(Library library)
{
_functions = library.Functions.Database;
DatabaseHandle = new DatabaseHandle(library);
Library = library;
StreamPool = new StreamPool();
Serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = NejdbContractResolver.Instance,
};
Serializer.Converters.Add(ObjectIdConverter.Instance);
}
public override void ManageStream()
{
if (this.Stream.GetState != this.StreamprocessingType)
{
StreamPool.returnStream(this.Stream);
this.ChangeState = runningState.incorrectInput;
return;
}
StreamModifier myMod = new StreamModifier(myMultiplier);
this.Stream.AddModifier = myMod;
// myAnimator.setAnimState(this);
this.PassStream();
}
public override void ManageStream()
{
if (this.Stream.GetState != this.StreamprocessingType)
{
StreamPool.returnStream(this.Stream);
this.ChangeState = runningState.incorrectInput;
return;
}
// base.ManageStream();
isRecivingStream = true;
ResourceStream myStream = this.Stream;
float myStreamValue = myStream.GetStreamValue();
ResourceManager.rManager.curResource += myStreamValue;
StreamPool.returnStream(this.Stream);
//Destroy (myStream); //This is temp until I set up object pooling
// Debug.LogError("Should be better");
}
/// <summary>
/// <para>Gets the expiration time of an object.</para>
/// </summary>
/// <param name="keySpace">
/// <para>The key space of the entry.</para>
/// </param>
/// <param name="key">
/// <para>The key of the entry.</para>
/// </param>
/// <returns>
/// <para>A <see cref="Nullable{DateTime}"/> containing the expiration time if found; otherwise <see langword="null"/>.</para>
/// </returns>
public DateTime?GetExpires(DataBuffer keySpace, StorageKey key)
{
using (var item = StreamPool.GetItem())
{
var stream = item.Item;
if (stream.Capacity < sizeof(long))
{
stream.Capacity = sizeof(long);
}
var buffer = GetReadBuffer(stream);
buffer = buffer.Restrict(sizeof(long));
var len = Storage.Get(keySpace, key, 0, buffer);
if (len < 0)
{
return(null);
}
var seg = buffer.ByteArraySegmentValue;
var ticks = BitConverter.ToInt64(seg.Array, seg.Offset);
return(new DateTime(ticks));
}
}
public void PassStream()
{
// Debug.Log(this.transform.name + "Is passing OBJ");
myNeighbors.Clear();
MyNeighborOutPut.Clear();
for (int output = 0; output < myOutputs.Count; output++)
{
// Debug.Log(myOutputs[output]);
if (myParent.GetNeighbor(myOutputs[output]) != null)
{
if (myInputs.Contains(myOutputs[output]))
{
myInputs.Remove(myOutputs[output]);
}
myNeighbors.Add(myParent.GetNeighbor(myOutputs [output]));
MyNeighborOutPut.Add(myOutputs [output]);
// .ReceiveStream(myStream, myOutputs[output]);
// return;
}
}
//Debug.Log (myStream.currentValue);
//myStream.currentValue = myStream.currentValue / myNeighbors.Count + 1;
//Debug.Log (myStream.currentValue + " : " + myNeighbors.Count);
if (myNeighbors.Count > 0)
{
myState = runningState.running;
for (int neighbor = 0; neighbor < myNeighbors.Count; neighbor++)
{
myNeighbors [neighbor].ReceiveStream(myStream, MyNeighborOutPut [neighbor]);
}
}
else
{
StreamPool.returnStream(this.Stream);
myState = runningState.incorrectOutput;
}
ManageAnimator();
}
