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(""); }