public static string RunCommand(this Command query, string url, IVariableContainer values = null)
{
var client = new WebClient();
client.Headers["Accept"] = "application/json";
client.Headers["Content-Type"] = "application/json";
StringWriter sw = new StringWriter();
JsonWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("query");
writer.WriteValue(query.QueryText);
if (values != null)
{
writer.WritePropertyName("variables");
writer.WriteValue(values.GetJSON());
}
if (query.QueryName != null)
{
writer.WritePropertyName("operationName");
writer.WriteValue(query.QueryName);
}
writer.WriteEndObject();
var text = sw.ToString();
return(client.UploadString(url, "POST", text));
}
public static void ImportInto(IVariableContainer source, IVariableContainer target)
{
foreach (var variable in source.GetVariables())
{
target.Overwrite(variable.GetReferenceCopy(source));
}
}
public static string GetKey(this IVariableContainer container, string variableName)
{
return(container.Variables.Keys
.FirstOrDefault(k =>
k.Equals(variableName,
StringComparison.InvariantCultureIgnoreCase)));
}
public static string GetJSON(this IVariableContainer container)
{
var writer = new StringGraphQLWriter();
writer.WriteLine("{");
bool first = true;
foreach (var v in container.Variables)
{
if (v.Value.HasValue)
{
if (first)
{
first = false;
}
else
{
writer.Write(", ");
}
writer.Write("\"" + v.Key + "\": ");
v.Value.Write(writer);
}
}
writer.WriteLine();
writer.WriteLine("}");
return(writer.CreateString());
}
public static void SetVariable(this IVariableContainer container, string variableName, object value)
{
var key = container.GetKey(variableName) ?? variableName;
lock (container.Variables)
{
container.Variables[key] = value;
}
}
public int AddVariableContainer(IVariableContainer container)
{
var id = container.GetHashCode();
if (variableContainers.TryAdd(id, container))
{
return(id);
}
throw new Exception();
}
internal static void SetParameter(IVariableContainer entity, string name, object p2)
{
if (Phantom.Library.Scene.SceneEntity.IsProcessed(name))
{
throw new ArgumentException("Not processed parameter!", name);
}
if (p2 is int)
{
entity[name].Set((int)p2);
}
else
if (p2 is float)
{
entity[name].Set((float)p2);
}
else
if (p2 is Vector3)
{
entity[name].SetFloat3((Vector3)p2);
}
else
if (p2 is Vector4)
{
entity[name].SetFloat4((Vector4)p2);
}
else if (p2 is Vector2)
{
entity[name].Set(((Vector2)p2).X, ((Vector2)p2).Y);
}
else if (p2 is IrrSPD16)
{
entity[name].SetUserData((IrrSPD16)p2);
}
else if (p2 is bool)
{
entity[name].Set(((bool)p2) ? 1 : 0);
}
else
{
var dataNode = p2 as DataNode;
if (dataNode != null)
{
entity[name].Set(dataNode);
}
else
{
throw new ArgumentException("Unsupported parameter type - " + p2.GetType().Name);
}
}
}
public static object GetVariable(this IVariableContainer container, string variableName)
{
var key = container.GetKey(variableName);
if (key == null)
{
return(null);
}
lock (container.Variables)
{
return(container.Variables[key]);
}
}
public static TO2Type FindVariable(this IVariableContainer current, IBlockContext context, string name)
{
while (current != null)
{
TO2Type variableType = current.FindVariableLocal(context, name);
if (variableType != null)
{
return(variableType);
}
current = current.ParentContainer;
}
return(null);
}
private static void WriteResult(IVariableContainer container)
{
int age = (int)container["age"];
Console.WriteLine("Age: {0}", age);
}
public abstract void SetVariable(object variable, IVariableContainer container);
public abstract VariableReference GetReferenceCopy(IVariableContainer container);
object GetValue_Container(IVariableContainer container)
{
return(container.GetValue(description.Value));
}
public AdapterVariableContainer(IVariableContainer adapter)
{
this.adapter = adapter;
}
public CapturedVariableProvider(IVariableContainer variableContainer, string environment, IVariableEncryptor encryptor)
{
_currentVariables = variableContainer;
_environment = environment;
_encryptor = encryptor;
}
public virtual void OnCameraUpdate(IVariableContainer context)
{
context["Y_log_av"].Set(yAvg);
context["Y_max"].Set(yMax);
context["gamma_value"].Set(gamma_value);
context["tonemapping"].Set(ToneMapping ? 1 : 0);
context["a_tm"].Set(this.a_tm);
}
public bool TryGet(int id, [MaybeNullWhen(false)] out IVariableContainer container)
{
return(containers.TryGetValue(id, out container));
}
public static TResult Run <TResult>(this Command <TResult> query, string url, IVariableContainer values = null)
{
var json = RunCommand(query, url, values);
var settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Error
};
settings.Converters.Add(new NotNullConverter());
settings.Converters.Add(new InterfaceConverter(query.Helper));
var resolver = new ContractResolver();
settings.ContractResolver = resolver;
resolver.UpdateContracts(null, query.Node);
var output = JsonConvert.DeserializeObject <Data <TResult> >(json, settings);
return(output.data);
}
