public void add(SampleDispatcher dispatcher,
SampleHandler handler)
{
lock (this) {
Entry e;
byDispatcher.TryGetValue(dispatcher, out e);
if (e != null)
{
e.check(dispatcher.getName(), dispatcher.getSignature());
e.setHandler(handler);
}
else
{
foreach (Entry e2 in byIndex.Values)
{
if (e2.match(dispatcher.getName(), dispatcher.getSignature()))
{
e2.setSampleDispatcher(dispatcher);
e2.setHandler(handler);
e = e2;
break;
}
}
if (e == null)
{
e = new Entry(dispatcher, handler);
byDispatcher.Add(dispatcher, e);
}
}
}
}
public void end(SampleDispatcher identity)
{
WritePacked32(writer, current_tag);
WritePacked32(writer, bytes.Length);
bytes.WriteTo(writer);
bytes.SetLength(0);
writer.Flush();
}
public Entry(SampleDispatcher dispatcher,
SampleHandler handler)
{
this.dispatcher = dispatcher;
this.name = dispatcher.getName();
this.signature = dispatcher.getSignature();
this.handler = handler;
}
private SampleDispatcher get(SampleDispatcher identity)
{
SampleDispatcher renamed;
lock (this) {
alias.TryGetValue(identity, out renamed);
}
return(renamed);
}
public void encodeSampleRef(SampleDispatcher value)
{
int index = 0;
try {
index = ref_registry.getTag(value);
} catch (NullReferenceException) {
}
WriteInt(index, 4);
}
private SampleDispatcher add(SampleDispatcher identity)
{
SampleDispatcher renamed;
lock (this) {
if (!alias.TryGetValue(identity, out renamed))
{
renamed = registry.add(identity, rename(identity.getName()));
alias.Add(identity, renamed);
}
}
get(identity);
return(renamed);
}
public int add(SampleDispatcher dispatcher)
{
lock (this) {
Entry e;
byDispatcher.TryGetValue(dispatcher, out e);
if (e == null)
{
e = new Entry(dispatcher, userIndex);
byDispatcher.Add(dispatcher, e);
userIndex++;
}
return(e.getIndex());
}
}
public int getTag(SampleDispatcher sample)
{
lock (this) {
Entry e;
byDispatcher.TryGetValue(sample, out e);
if (e == null)
{
throw new Exception("'" +
sample.ToString() +
"' is not registered");
}
return(e.getIndex());
}
}
public void registerSampleRef(SampleDispatcher dispatcher)
{
int index = ref_registry.add(dispatcher);
begin(Constant.SAMPLE_REF);
encodePacked32(index);
encodeIntentions(dispatcher.getName());
byte[] signature = dispatcher.getSignature();
encodePacked32(signature.Length);
for (int i = 0; i < signature.Length; i++)
{
encodeByte(signature[i]);
}
end(null);
}
public SampleDispatcher add(SampleDispatcher dispatcher,
String newName)
{
Dispatcher result;
Dispatcher tmp = new Dispatcher(dispatcher, newName);
lock (this) {
registry.TryGetValue(tmp, out result);
if (result == null)
{
registry.Add(tmp, tmp);
result = tmp;
}
}
return(result);
}
public virtual void end(SampleDispatcher dispatcher)
{
encoder.end(dispatcher);
}
public virtual void begin(SampleDispatcher dispatcher)
{
encoder.begin(dispatcher);
}
public virtual void registerSampleRef(SampleDispatcher dispatcher)
{
encoder.registerSampleRef(dispatcher);
}
public void setSampleDispatcher(SampleDispatcher dispatcher)
{
this.dispatcher = dispatcher;
}
public void begin(SampleDispatcher identity)
{
begin(def_registry.getTag(identity));
}
public virtual void register(SampleDispatcher dispatcher,
SampleHandler handler)
{
decoder.register(dispatcher, handler);
}
public Dispatcher(SampleDispatcher dispatcher,
String name)
{
this.dispatcher = dispatcher;
this.name = name;
}
public override void registerSampleRef(SampleDispatcher dispatcher)
{
decoder.registerSampleRef(registry.add(
dispatcher, rename(dispatcher.getName())));
}
public void register(SampleDispatcher dispatcher,
SampleHandler handler)
{
def_registry.add(dispatcher, handler);
}
public virtual void encodeSampleRef(SampleDispatcher value)
{
encoder.encodeSampleRef(value);
}
public override void end(SampleDispatcher identity)
{
base.end(get(identity));
}
public override void begin(SampleDispatcher identity)
{
base.begin(get(identity));
}
public override void registerSampleRef(SampleDispatcher identity)
{
encoder.registerSampleRef(add(identity));
}
public void runOne()
{
bool done = false;
while (!done)
{
int tag = decodePacked32();
int length = decodePacked32();
switch (tag)
{
case Constant.VERSION: {
String version = decodeString();
if (version != Constant.CURRENT_VERSION)
{
throw new IOException("LabComm version mismatch " +
version + " != " + Constant.CURRENT_VERSION);
}
} break;
case Constant.SAMPLE_DEF: {
int index = decodePacked32();
String name = decodeIntentions();
int signature_length = decodePacked32();
byte[] signature = new byte[signature_length];
ReadBytes(signature, signature_length);
def_registry.add(index, name, signature);
} break;
case Constant.SAMPLE_REF: {
int index = decodePacked32();
String name = decodeIntentions();
int signature_length = decodePacked32();
byte[] signature = new byte[signature_length];
ReadBytes(signature, signature_length);
ref_registry.add(index, name, signature);
} break;
case Constant.TYPE_DEF:
case Constant.TYPE_BINDING: {
for (int i = 0; i < length; i++)
{
decodeByte();
}
} break;
default: {
DecoderRegistry.Entry e = def_registry.get(tag);
if (e == null)
{
throw new IOException("Unhandled tag " + tag);
}
SampleDispatcher d = e.getSampleDispatcher();
if (d == null)
{
throw new IOException("No dispatcher for '" + e.getName() + "'" + e.getSignature());
}
SampleHandler h = e.getHandler();
if (h == null)
{
throw new IOException("No handler for '" + e.getName() + "'");
}
d.decodeAndHandle(this, h);
done = true;
} break;
}
}
}
public Entry(SampleDispatcher dispatcher, int index)
{
this.dispatcher = dispatcher;
this.index = index;
}
public void registerSampleRef(SampleDispatcher dispatcher)
{
ref_registry.add(dispatcher, null);
}
public override void register(SampleDispatcher dispatcher,
SampleHandler handler)
{
decoder.register(registry.add(
dispatcher, rename(dispatcher.getName())), handler);
}
