static CommonObject CommonObjectFromJToken(JToken jsonElement)
{
int archive3dm = (int)jsonElement["archive3dm"];
int opennurbs = (int)jsonElement["opennurbs"];
string data = (string)jsonElement["data"];
return(CommonObject.FromBase64String(archive3dm, opennurbs, data));
}
static object ToObjectHelper(JToken jsonElement, Type objectType, JsonSerializer serializer)
{
if (typeof(CommonObject).IsAssignableFrom(objectType))
{
int archive3dm = (int)jsonElement["archive3dm"];
int opennurbs = (int)jsonElement["opennurbs"];
string data = (string)jsonElement["data"];
CommonObject rc = CommonObject.FromBase64String(archive3dm, opennurbs, data);
// Steve: I'm still undecided on if we should 'magically' convert
//if(objectType.Equals(typeof(Brep)) && rc is Extrusion)
//{
// Extrusion extrusion = rc as Extrusion;
// return extrusion.ToBrep();
//}
return(rc);
}
if (serializer == null)
{
return(jsonElement.ToObject(objectType));
}
return(jsonElement.ToObject(objectType, serializer));
}
string HandlePostHelper(Newtonsoft.Json.Linq.JArray ja, Dictionary <string, string> returnModifiers)
{
int tokenCount = ja == null ? 0 : ja.Count;
if (_methods != null)
{
JsonSerializer serializer = new JsonSerializer();
serializer.Converters.Add(new ArchivableDictionaryResolver());
int methodIndex = -1;
foreach (var method in _methods)
{
methodIndex++;
int paramCount = method.GetParameters().Length;
if (!method.IsStatic)
{
paramCount++;
}
foreach (var parameter in method.GetParameters())
{
if (parameter.IsOut)
{
paramCount--;
}
}
if (paramCount == tokenCount)
{
var methodParameters = method.GetParameters();
object invokeObj = null;
object[] invokeParameters = new object[methodParameters.Length];
int currentJa = 0;
if (!method.IsStatic)
{
invokeObj = ja[currentJa++].ToObject(_classType);
}
int outParamCount = 0;
try
{
for (int i = 0; i < methodParameters.Length; i++)
{
if (!methodParameters[i].IsOut)
{
var jsonobject = ja[currentJa++];
var generics = methodParameters[i].ParameterType.GetGenericArguments();
Type objectType = null;
bool useSerializer = true;
if (generics == null || generics.Length != 1)
{
objectType = methodParameters[i].ParameterType;
useSerializer = true;
}
else
{
objectType = generics[0].MakeArrayType();
useSerializer = false;
}
invokeParameters[i] = DataCache.GetCachedItem(jsonobject, objectType, useSerializer ? serializer : null);
if (invokeParameters[i] == null)
{
if (useSerializer)
{
invokeParameters[i] = jsonobject.ToObject(objectType, serializer);
}
else
{
if (objectType == typeof(GeometryBase[]))
{
// 6 Sept 2020 S. Baer
// This needs to be tuned up. Json.Net is having issues creating arrays of
// GeometryBase since that class is abstract. I think we need to generalize this
// solution, but for now I can repeat the issue when calling
// AreaMassProperties.Compute(IEnumerable<GeometryBase>)
// from an endpoint
GeometryBase[] items = new GeometryBase[jsonobject.Count()];
for (int itemIndex = 0; itemIndex < items.Length; itemIndex++)
{
var jsonElement = jsonobject[itemIndex];
int archive3dm = (int)jsonElement["archive3dm"];
int opennurbs = (int)jsonElement["opennurbs"];
string data = (string)jsonElement["data"];
items[itemIndex] = CommonObject.FromBase64String(archive3dm, opennurbs, data) as GeometryBase;
}
invokeParameters[i] = items;
}
else
{
invokeParameters[i] = jsonobject.ToObject(objectType);
}
}
}
}
if (methodParameters[i].IsOut || methodParameters[i].ParameterType.IsByRef)
{
outParamCount++;
}
}
}
catch (Exception ex)
{
if (methodIndex < (_methods.Count() - 1))
{
continue;
}
throw ex;
}
bool isConst = false;
if (!method.IsStatic)
{
object[] methodAttrs = method.GetCustomAttributes(true);
if (methodAttrs != null)
{
for (int i = 0; i < methodAttrs.Length; i++)
{
Attribute attr = methodAttrs[i] as Attribute;
if (attr != null && attr.ToString().Contains("ConstOperationAttribute"))
{
isConst = true;
break;
}
}
}
}
if (method.ReturnType != typeof(void) || (!method.IsStatic && !isConst))
{
outParamCount++;
}
var invokeResult = method.Invoke(invokeObj, invokeParameters);
if (outParamCount < 1)
{
return("");
}
object[] rc = new object[outParamCount];
int outputSlot = 0;
if (method.ReturnType != typeof(void))
{
rc[outputSlot++] = invokeResult;
}
else if (!method.IsStatic && !isConst)
{
rc[outputSlot++] = invokeObj;
}
for (int i = 0; i < methodParameters.Length; i++)
{
if (methodParameters[i].IsOut || methodParameters[i].ParameterType.IsByRef)
{
rc[outputSlot++] = invokeParameters[i];
}
}
if (returnModifiers != null && returnModifiers.Count > 0)
{
for (int i = 0; i < rc.Length; i++)
{
rc[i] = ProcessModifiers(rc[i], returnModifiers);
}
}
if (rc.Length == 1)
{
return(Newtonsoft.Json.JsonConvert.SerializeObject(rc[0], GeometryResolver.Settings));
}
return(Newtonsoft.Json.JsonConvert.SerializeObject(rc, GeometryResolver.Settings));
}
}
}
if (_constructors != null)
{
for (int k = 0; k < _constructors.Length; k++)
{
var constructor = _constructors[k];
int paramCount = constructor.GetParameters().Length;
if (paramCount == tokenCount)
{
object[] parameters = new object[tokenCount];
var p = constructor.GetParameters();
try
{
bool skipThisConstructor = false;
for (int ip = 0; ip < tokenCount; ip++)
{
var generics = p[ip].ParameterType.GetGenericArguments();
if (generics == null || generics.Length != 1)
{
if (_constructors.Length > 0 && p[ip].ParameterType == typeof(Rhino.Geometry.Plane))
{
if (ja[ip].Count() < 4)
{
skipThisConstructor = true;
ip = tokenCount;
continue;
}
}
parameters[ip] = ja[ip].ToObject(p[ip].ParameterType);
}
else
{
var arrayType = generics[0].MakeArrayType();
parameters[ip] = ja[ip].ToObject(arrayType);
}
}
if (skipThisConstructor)
{
continue;
}
}
catch (Exception)
{
continue;
}
var rc = constructor.Invoke(parameters);
rc = ProcessModifiers(rc, returnModifiers);
return(Newtonsoft.Json.JsonConvert.SerializeObject(rc, GeometryResolver.Settings));
}
}
}
return("");
}