public static Offset <NeuronId> CreateNeuronId(FlatBufferBuilder builder,
uint neuron = 0,
uint region = 0)
{
builder.StartObject(2);
NeuronId.AddRegion(builder, region);
NeuronId.AddNeuron(builder, neuron);
return(NeuronId.EndNeuronId(builder));
}
public static RequestMessage Build(bool full, ModelFilter filter = null, IList <ObserverDefinition> observerRequests = null)
{
var builder = new FlatBufferBuilder(RequestMessageBuilder.BufferInitialSize);
Offset <Filter>?filterOffset = null;
if (filter != null)
{
var boxes = new Offset <Box3D> [filter.Boxes.Count];
filter.Boxes.EachWithIndex((i, box) =>
{
boxes[i] = Box3D.CreateBox3D(builder,
box.LowerBound.X,
box.LowerBound.Y,
box.LowerBound.Z,
box.Size.X,
box.Size.Y,
box.Size.Z);
});
VectorOffset boxesOffset = Filter.CreateBoxesVector(builder, boxes);
filterOffset = Filter.CreateFilter(builder, boxesOffset);
}
VectorOffset?observersVectorOffset = null;
if (observerRequests != null)
{
var observerOffsets = new Offset <Observer> [observerRequests.Count()];
observerRequests.EachWithIndex((i, definition) =>
{
Offset <NeuronId> neuronId = NeuronId.CreateNeuronId(builder, definition.NeuronIndex,
definition.RegionIndex);
StringOffset observerType = builder.CreateString(definition.Type);
observerOffsets[i] = Observer.CreateObserver(builder, neuronId, observerType);
});
observersVectorOffset = GetModelRequest.CreateObserversVector(builder, observerOffsets);
}
GetModelRequest.StartGetModelRequest(builder);
GetModelRequest.AddFull(builder, full);
if (filterOffset.HasValue)
{
GetModelRequest.AddFilter(builder, filterOffset.Value);
}
if (observersVectorOffset.HasValue)
{
GetModelRequest.AddObservers(builder, observersVectorOffset.Value);
}
Offset <GetModelRequest> requestOffset = GetModelRequest.EndGetModelRequest(builder);
return(RequestMessageBuilder.Build(builder, Request.GetModelRequest, requestOffset));
}
private static Offset <Synapse>[] BuildSynapseOffsets(IList <SynapseModel> synapses, FlatBufferBuilder builder)
{
Offset <Synapse>[] addedSynapsesOffsets = BuildOffsets(synapses,
synapse =>
{
var fromNeuronId = NeuronId.CreateNeuronId(builder, synapse.FromNeuron.Index, synapse.FromRegion.Index);
var toNeuronId = NeuronId.CreateNeuronId(builder, synapse.ToNeuron.Index, synapse.ToRegion.Index);
return(Synapse.CreateSynapse(builder, fromNeuronId, toNeuronId));
});
return(addedSynapsesOffsets);
}
private static VectorOffset?BuildRemovedNeurons(IList <NeuronModel> removedNeurons, FlatBufferBuilder builder)
{
Offset <NeuronId>[] removedNeuronsOffsets = BuildOffsets(removedNeurons,
neuron => NeuronId.CreateNeuronId(builder, neuron.Index, neuron.RegionModel.Index));
if (removedNeuronsOffsets == null)
{
return(null);
}
return(ModelResponse.CreateRemovedNeuronsVector(builder, removedNeuronsOffsets));
}
private static Offset <ObserverResult> BuildObserverOffset(FlatBufferBuilder builder, ObserverDataContainer observer)
{
var neuronId = NeuronId.CreateNeuronId(builder, observer.Definition.NeuronIndex,
observer.Definition.RegionIndex);
var observerType = builder.CreateString(observer.Definition.Type);
var observerOffset = Observer.CreateObserver(builder, neuronId, observerType);
VectorOffset?metadataOffset = null;
if (observer.Data.Metadata != null)
{
metadataOffset = ObserverResult.CreateMetadataVector(builder, observer.Data.Metadata);
}
VectorOffset?plainDataOffset = null;
if (observer.Data.PlainData != null)
{
plainDataOffset = ObserverResult.CreatePlainDataVector(builder, observer.Data.PlainData);
}
VectorOffset?floatDataOffset = null;
if (observer.Data.FloatData != null)
{
floatDataOffset = ObserverResult.CreateFloatDataVector(builder, observer.Data.FloatData);
}
ObserverResult.StartObserverResult(builder);
ObserverResult.AddObserver(builder, observerOffset);
if (metadataOffset.HasValue)
{
ObserverResult.AddMetadata(builder, metadataOffset.Value);
}
if (plainDataOffset.HasValue)
{
ObserverResult.AddPlainData(builder, plainDataOffset.Value);
}
if (floatDataOffset.HasValue)
{
ObserverResult.AddFloatData(builder, floatDataOffset.Value);
}
return(ObserverResult.EndObserverResult(builder));
}
private static Offset <Neuron>[] BuildNeuronOffsets(IList <NeuronModel> neurons, FlatBufferBuilder builder)
{
Offset <Neuron>[] addedNeuronsOffsets = BuildOffsets(neurons, neuron =>
{
StringOffset type = builder.CreateString(neuron.Type);
Offset <Position> position = Position.CreatePosition(builder, neuron.Position.X, neuron.Position.Y,
neuron.Position.Z);
var neuronId = NeuronId.CreateNeuronId(builder, neuron.Index, neuron.RegionModel.Index);
return(Neuron.CreateNeuron(builder, neuronId, type, position));
});
return(addedNeuronsOffsets);
}
public static NeuronId GetRootAsNeuronId(ByteBuffer _bb, NeuronId obj)
{
return(obj.__init(_bb.GetInt(_bb.Position) + _bb.Position, _bb));
}
public NeuronId GetNeuronId(NeuronId obj)
{
int o = __offset(4); return(o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null);
}
