using System;

using System.Threading;

using System.Runtime.InteropServices;

using System.Collections;

using System.Collections.Generic;

namespace Mapper

[Flags]

public enum Type

}

public enum Operator

}

[StructLayout(LayoutKind.Explicit)]

public struct MprTime

}

public class Time

}

public enum Property

}

public abstract class Object

{

public enum Status

}

public Object()

}

protected Object(IntPtr obj)

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

protected static extern int mpr_obj_get_type(IntPtr obj);

public new Type GetType()

{ return (Type) mpr_obj_get_type(_obj); }

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern int mpr_obj_get_num_props(IntPtr obj);

public int GetNumProperties()

{ return mpr_obj_get_num_props(_obj); }

unsafe internal object BuildValue(int len, int type, void *value, int property)

{

if (0 == len)

return null;

if (value == null)

return null;

switch (type)

{

case (int)Type.Int32:

if (1 == len)

{

int i = *(int*)value;

switch (property)

{

case (int)Property.Direction:

return (Signal.Direction)i;

case (int)Property.ProcessingLocation:

return (Map.Location)i;

case (int)Property.Protocol:

return (Map.Protocol)i;

case (int)Property.Status:

return (Object.Status)i;

case (int)Property.Stealing:

return (Signal.Stealing)i;

case (int)Property.Type:

return (Type)i;

default:

return i;

}

}

else

{

int[] arr = new int[len];

Marshal.Copy((IntPtr)value, arr, 0, len);

return arr;

}

case (int)Type.Float:

if (1 == len)

return *(float*)value;

else

{

float[] arr = new float[len];

Marshal.Copy((IntPtr)value, arr, 0, len);

return arr;

}

case (int)Type.Double:

if (1 == len)

return *(double*)value;

else

{

double[] arr = new double[len];

Marshal.Copy((IntPtr)value, arr, 0, len);

return arr;

}

case (int)Type.Boolean:

if (1 == len)

return *(int*)value != 0;

else

{

bool[] arr = new bool[len];

for (int i = 0; i < len; i++)

arr[i] = ((int*)value)[i] != 0;

return arr;

}

case (int)Type.Int64:

if (1 == len)

return *(long*)value;

else

{

long[] arr = new long[len];

Marshal.Copy((IntPtr)value, arr, 0, len);

return arr;

}

case (int)Type.Time:

if (1 == len)

return new Time(*(long*)value);

else

{

Time[] arr = new Time[len];

for (int i = 0; i < len; i++)

arr[0] = new Time(((long*)value)[i]);

return arr;

}

case (int)Type.String:

if (1 == len)

return new String(Marshal.PtrToStringAnsi((IntPtr)value));

else

{

String[] arr = new String[len];

for (int i = 0; i < len; i++)

arr[i] = new String(Marshal.PtrToStringAnsi((IntPtr)((char**)value)[i]));

return arr;

}

case (int)Type.Device:

return new Device((IntPtr)value);

case (int)Type.Map:

return new Map((IntPtr)value);

case (int)Type.Signal:

return new Signal((IntPtr)value);

case (int)Type.List:

if (1 == len)

{

switch (property)

{

case (int)Property.Device:

case (int)Property.Linked:

case (int)Property.Scope:

return new List<Device>((IntPtr)value, Type.Device);

case (int)Property.Signal:

return new List<Signal>((IntPtr)value, Type.Signal);

default:

Console.WriteLine("error: missing List type.");

return null;

}

}

else

{

Console.WriteLine("error: arrays of List are not currently supported.");

return null;

}

default:

Console.WriteLine("error: unhandled data type in Object.BuildValue().");

return null;

}

}

// TODO: implement IDictionary?

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

unsafe internal static extern int mpr_obj_get_prop_by_idx(IntPtr obj, int idx, ref char *key,

ref int len, ref int type,

ref void *value, ref int publish);

unsafe public (String, object) GetProperty(int index)

{

char *key = null;

int len = 0;

int type = 0;

void *val = null;

int pub = 0;

int idx = mpr_obj_get_prop_by_idx(this._obj, index, ref key, ref len,

ref type, ref val, ref pub);

if (0 == idx || 0 == len)

return (new String("unknown"), null);

return (new string(Marshal.PtrToStringAnsi((IntPtr)key)), BuildValue(len, type, val, idx));

}

unsafe public object GetProperty(Property property)

{

char *key = null;

int len = 0;

int type = 0;

void *val = null;

int pub = 0;

int idx = mpr_obj_get_prop_by_idx(this._obj, (int)property, ref key, ref len,

ref type, ref val, ref pub);

if (0 == idx || 0 == len)

return null;

return BuildValue(len, type, val, idx);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

unsafe internal static extern int mpr_obj_get_prop_by_key(IntPtr obj,

[MarshalAs(UnmanagedType.LPStr)] string key,

ref int len, ref int type,

ref void *value, ref int publish);

unsafe public object GetProperty(string key)

{

int len = 0;

int type = 0;

void *val = null;

int pub = 0;

int idx;

idx = mpr_obj_get_prop_by_key(this._obj, key, ref len, ref type, ref val, ref pub);

if (0 == idx || 0 == len)

return null;

return BuildValue(len, type, val, idx);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

unsafe internal static extern

int mpr_obj_get_prop_as_int32(IntPtr obj, int prop, [MarshalAs(UnmanagedType.LPStr)] string key);

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

unsafe internal static extern

int mpr_obj_set_prop(IntPtr obj, int prop, [MarshalAs(UnmanagedType.LPStr)] string key,

int len, int type, void* value, int publish);

unsafe public Object SetProperty<P, T>(P property, T value, bool publish)

{

int _prop = 0, _pub = Convert.ToInt32(publish);

string _key = null;

switch (property)

{

case Property p: _prop = (int)p; break;

case string s: _key = s; break;

default:

Console.WriteLine("error: unknown property specifier in method SetProperty().");

return this;

}

switch (value)

{

case int i:

mpr_obj_set_prop(_obj, _prop, _key, 1, (int)Type.Int32, (void*)&i, _pub);

break;

case float f:

mpr_obj_set_prop(_obj, _prop, _key, 1, (int)Type.Float, (void*)&f, _pub);

break;

case double d:

mpr_obj_set_prop(_obj, _prop, _key, 1, (int)Type.Double, (void*)&d, _pub);

break;

case bool b:

{

int i = Convert.ToInt32(b);

mpr_obj_set_prop(_obj, _prop, _key, 1, (int)Type.Boolean, (void*)&i, _pub);

}

break;

case string s:

mpr_obj_set_prop(_obj, _prop, _key, 1, (int)Type.String, (void*)Marshal.StringToHGlobalAnsi(s), _pub);

break;

case int[] i:

fixed(int *temp = &i[0])

{

IntPtr intPtr = new IntPtr((void*)temp);

mpr_obj_set_prop(_obj, _prop, _key, i.Length, (int)Type.Int32, (void*)intPtr, _pub);

}

break;

case float[] f:

fixed(float *temp = &f[0])

{

IntPtr intPtr = new IntPtr((void*)temp);

mpr_obj_set_prop(_obj, _prop, _key, f.Length, (int)Type.Float, (void*)intPtr, _pub);

}

break;

case double[] d:

fixed(double *temp = &d[0])

{

IntPtr intPtr = new IntPtr((void*)temp);

mpr_obj_set_prop(_obj, _prop, _key, d.Length, (int)Type.Double, (void*)intPtr, _pub);

}

break;

default:

Console.WriteLine("error: unhandled type in SetProperty().");

break;

}

return this;

}

public Object SetProperty<P, T>(P property, T value)

{

return SetProperty(property, value, true);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern int mpr_obj_remove_prop(IntPtr obj, int prop,

[MarshalAs(UnmanagedType.LPStr)] string key);

public bool RemoveProperty<P>(P property)

{

int _prop = 0;

string _key = null;

switch (property)

{

case Property p: _prop = (int)p; break;

case string s: _key = s; break;

default:

Console.WriteLine("error: unknown property specifier in method SetProperty().");

return false;

}

return 0 != mpr_obj_remove_prop(this._obj, _prop, _key);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern void mpr_obj_push(IntPtr obj);

public Object Push()

{

mpr_obj_push(_obj);

return this;

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_obj_get_graph(IntPtr obj);

public Graph GetGraph()

{

return new Graph(mpr_obj_get_graph(_obj));

}

internal IntPtr _obj;

internal bool _owned;

}

public abstract class _List {

protected Type _type;

private IntPtr _list;

private bool _started;

public _List()

{

_type = Type.Null;

_list = IntPtr.Zero;

_started = false;

}

public _List(IntPtr list, Type type)

{

_type = type;

_list = list;

_started = false;

}

/* copy constructor */

public _List(_List original)

{

_list = mpr_list_get_cpy(original._list);

_type = original._type;

_started = false;

}

// TODO: probably need refcounting to check if we should free the underlying mpr_list

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern void mpr_list_free(IntPtr list);

public void Free()

{

mpr_list_free(_list);

_list = IntPtr.Zero;

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern int mpr_list_get_size(IntPtr list);

public int Count()

{

return mpr_list_get_size(_list);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_idx(IntPtr list, int index);

public IntPtr GetIdx(int index)

{

return mpr_list_get_idx(_list, index);

}

public IntPtr Deref()

{

unsafe {

return new IntPtr(_list != IntPtr.Zero ? *(void**)_list : null);

}

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_cpy(IntPtr list);

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_union(IntPtr list1, IntPtr list2);

public _List Join(_List rhs)

{

_list = mpr_list_get_union(_list, mpr_list_get_cpy(rhs._list));

return this;

}

public static IntPtr Union(_List a, _List b)

{

return mpr_list_get_union(mpr_list_get_cpy(a._list), mpr_list_get_cpy(b._list));

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_isect(IntPtr list1, IntPtr list2);

public _List Intersect(_List rhs)

{

_list = mpr_list_get_isect(_list, mpr_list_get_cpy(rhs._list));

return this;

}

public static IntPtr Intersection(_List a, _List b)

{

return mpr_list_get_isect(mpr_list_get_cpy(a._list), mpr_list_get_cpy(b._list));

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_diff(IntPtr list1, IntPtr list2);

public _List Subtract(_List rhs)

{

_list = mpr_list_get_diff(_list, mpr_list_get_cpy(rhs._list));

return this;

}

public static IntPtr Difference(_List a, _List b)

{

return mpr_list_get_diff(mpr_list_get_cpy(a._list), mpr_list_get_cpy(b._list));

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_list_get_next(IntPtr list);

public bool GetNext()

{

if (_started)

{

_list = mpr_list_get_next(_list);

}

else

_started = true;

return _list != IntPtr.Zero;

}

public override string ToString() => $"Mapper.List<{_type}>";

}

public class List<T> : _List, IEnumerator, IEnumerable, IDisposable

where T : Object, new()

{

internal List(IntPtr list, Type type) : base(list, type) {}

public T this[int index]

{

get { T t = new T(); t._obj = this.GetIdx(index); return t; }

}

/* Overload some arithmetic operators */

public static List<T> operator +(List<T> a, List<T> b)

=> new List<T>( Union(a, b), a._type );

public static List<T> operator *(List<T> a, List<T> b)

=> new List<T>( Intersection(a, b), a._type );

public static List<T> operator -(List<T> a, List<T> b)

=> new List<T>( Difference(a, b), a._type );

/* Methods for enumeration */

public IEnumerator GetEnumerator()

{

return (IEnumerator)this;

}

public void Reset()

{

// TODO: throw NotSupportedException;

}

public bool MoveNext()

{

return this.GetNext();

}

void IDisposable.Dispose()

{

this.Free();

}

public T Current

{

get

{

T t = new T();

t._obj = this.Deref();

return t;

}

}

object IEnumerator.Current

{

get

{

return Current;

}

}

}

public class Graph : Object

{

private delegate void HandlerDelegate(IntPtr graph, IntPtr obj, int evt, IntPtr data);

public enum Event

{

New, //!< New record has been added to the graph.

Modified, //!< The existing record has been modified.

Removed, //!< The existing record has been removed.

Expired //!< The graph has lost contact with the remote entity.

}

internal Graph(IntPtr obj) : base(obj) {}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_graph_new(int flags);

public Graph(Type flags) : base(mpr_graph_new((int)flags))

{ _owned = true; }

public Graph() : base(mpr_graph_new((int)Type.Object))

{ _owned = true; }

// TODO: check if Graph is used by a Device

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern void mpr_graph_free(IntPtr graph);

~Graph()

{ if (_owned) mpr_graph_free(this._obj); }

public new Graph SetProperty<P, T>(P property, T value, bool publish)

{

base.SetProperty(property, value, publish);

return this;

}

public new Graph SetProperty<P, T>(P property, T value)

{

base.SetProperty(property, value, true);

return this;

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern void mpr_graph_set_interface(IntPtr graph,

[MarshalAs(UnmanagedType.LPStr)] string iface);

public Graph SetInterface(string iface)

{

mpr_graph_set_interface(this._obj, iface);

return this;

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern IntPtr mpr_graph_get_interface(IntPtr graph);

public string GetInterface()

{

IntPtr iface = mpr_graph_get_interface(this._obj);

return Marshal.PtrToStringAnsi(iface);

}

[DllImport("mapper", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]

private static extern void mpr_graph_set_address(IntPtr graph,

[MarshalAs(UnmanagedType.LPStr)] string group,