protected override IDataFlowGraphExpressionNode Visit(ConstantString con)
{
var op = new InputConst(Guid.NewGuid(), new Value(con.Value));
_dataFlowGraph._inputs.Add(op);
return(op);
}
public static ConstantPoolInfo Read(ClassReader classReader)
{
ushort tag = classReader.ReadU1();
ConstantPoolInfo constantPoolInfo = null;
switch (tag)
{
case 7:
constantPoolInfo = new ConstantClass(); break;
case 9:
constantPoolInfo = new ConstantFieldRef(); break;
case 10:
constantPoolInfo = new ConstantMethodRef(); break;
case 11:
constantPoolInfo = new ConstantInterfaceMethodRef(); break;
case 8:
constantPoolInfo = new ConstantString(); break;
case 3:
constantPoolInfo = new ConstantInteger(); break;
case 4:
constantPoolInfo = new ConstantFloat(); break;
case 5:
constantPoolInfo = new ConstantLong(); break;
case 6:
constantPoolInfo = new ConstantDouble(); break;
case 12:
constantPoolInfo = new ConstantNameAndType(); break;
case 1:
constantPoolInfo = new ConstantUtf8(); break;
case 15:
constantPoolInfo = new ConstantMethodHandle(); break;
case 16:
constantPoolInfo = new ConstantMethodType(); break;
case 18:
constantPoolInfo = new ConstantInvokeDynamic(); break;
default:
throw new Exception("ClassFileError:constantPoolInfo incorrect");
}
constantPoolInfo.Tag = tag;
constantPoolInfo.ReadConstantPoolInfo(classReader);
return(constantPoolInfo);
}
public IBuildIntention <IConstantString> GetBuildIntention(IConversionContext context)
{
var(toBuild, maker) = ConstantString.Create();
return(new BuildIntention <IConstantString>(toBuild, () =>
{
maker.Build(
Value.GetOrThrow());
}));
}
static BaseExpression HandleExpression(BaseExpression right)
{
return(right switch {
Variable v => new Increment(v.Name),
ConstantNumber n => new ConstantNumber(new Add(n, new ConstantNumber((Number)1)).StaticEvaluate().Number),
ConstantString s => new ConstantString(s.Value + " "),
Bracketed b => HandleExpression(b.Parameter),
_ => throw new InvalidOperationException(right.GetType().Name)
});
public void ExpressionFactoryString_SuccessfullyCreates_ConstantStringExpression_Test()
{
//Arrange
var constantString = new ConstantString <IContext>("foo");
//Act
var sut = _expressions.String("foo");
//Assert
Assert.True(sut.Interpret(_context) == constantString.Interpret(_context));
}
protected override BaseExpression Visit(ConstantString con)
{
if (_replacements.TryGetValue(new Value(con.Value), out var name))
{
return(new Variable(new VariableName(name)));
}
else
{
return(con);
}
}
protected override BaseExpression Visit(Bracketed brk)
{
var inner = Visit(brk.Parameter);
return(inner switch
{
Variable v => v,
ConstantNumber n => n,
ConstantString s => s,
Bracketed b => b,
_ => base.Visit(new Bracketed(inner)),
});
public virtual TResult Visit(BaseExpression expression)
{
return(expression switch {
Phi a => Visit(a),
Increment a => Visit(a),
Decrement a => Visit(a),
ErrorExpression a => Visit(a),
Bracketed a => Visit(a),
Abs a => Visit(a),
Sqrt a => Visit(a),
Sine a => Visit(a),
Cosine a => Visit(a),
Tangent a => Visit(a),
ArcSine a => Visit(a),
ArcCos a => Visit(a),
ArcTan a => Visit(a),
PostIncrement a => Visit(a),
PreIncrement a => Visit(a),
PostDecrement a => Visit(a),
PreDecrement a => Visit(a),
Add a => Visit(a),
Subtract a => Visit(a),
Multiply a => Visit(a),
Divide a => Visit(a),
Modulo a => Visit(a),
Negate a => Visit(a),
Exponent a => Visit(a),
Or a => Visit(a),
And a => Visit(a),
Not a => Visit(a),
Factorial a => Visit(a),
Variable a => Visit(a),
ConstantNumber a => Visit(a),
ConstantString a => Visit(a),
EqualTo a => Visit(a),
NotEqualTo a => Visit(a),
GreaterThan a => Visit(a),
GreaterThanEqualTo a => Visit(a),
LessThan a => Visit(a),
LessThanEqualTo a => Visit(a),
_ => VisitUnknown(expression)
});
public string GetNewConnection(HttpContext httpContext)
{
ConstantString constantString = new ConstantString();
string host = string.Empty;
#if !DEBUG
StringValues authorizationToken;
var tokenExist = httpContext.Request.Headers.TryGetValue("Authorization", out authorizationToken);// get host name from token
if (tokenExist)
{
//get the host name from request
TokenModel token = CommonMethods.GetTokenDataModel(httpContext);
host = token.DomainName;
}
else if (httpContext.Request.QueryString.Value.Contains("Business")) // before login get verified host name from query string
{
host = httpContext.Request.QueryString.Value.Split("=")[1];
}
else if (httpContext.Request.QueryString.Value.Contains("access_token")) // this is for chathub access_token is passed from frontend to access dyanmic database
{
host = httpContext.Request.QueryString.Value.Split("=")[2];
httpContext.Request.Headers.Add("Authorization", $"Bearer {host}");
TokenModel token = CommonMethods.GetTokenDataModel(httpContext);
host = token.DomainName;
}
else
{
httpContext.Request.Headers.TryGetValue("BusinessToken", out authorizationToken); //get host name from header
host = CommonMethods.Decrypt(authorizationToken);
}
#else
//its only for debug mode
host = HCOrganizationConnectionStringEnum.Host; //its Merging db
#endif
//return new connetion string which made from request host
return(GetDomain(host));
}
static void HandleConstants(GraphBuilder builder, out INode node, out PortMapper portToOffsetMapping,
IConstantNodeModel constantNodeModel)
{
portToOffsetMapping = new PortMapper();
var outputPortId = constantNodeModel.OutputPort?.UniqueId ?? "";
switch (constantNodeModel)
{
case StringConstantModel stringConstantModel:
{
var index = builder.StoreStringConstant(stringConstantModel.value ?? string.Empty);
var cf = new ConstantString {
Value = new StringReference(index, StringReference.Storage.Managed)
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case BooleanConstantNodeModel booleanConstantNodeModel:
{
var cf = new ConstantBool {
Value = booleanConstantNodeModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case IntConstantModel intConstantModel:
{
var cf = new ConstantInt {
Value = intConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case FloatConstantModel floatConstantModel:
{
var cf = new ConstantFloat {
Value = floatConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector2ConstantModel vector2ConstantModel:
{
var cf = new ConstantFloat2 {
Value = vector2ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector3ConstantModel vector3ConstantModel:
{
var cf = new ConstantFloat3 {
Value = vector3ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector4ConstantModel vector4ConstantModel:
{
var cf = new ConstantFloat4 {
Value = vector4ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case QuaternionConstantModel quaternionConstantModel:
{
var cf = new ConstantQuaternion {
Value = quaternionConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case ObjectConstantModel _:
{
throw new NotImplementedException(
"Conversion and all - either a prefab (might live in a graph) or a scene object (must be injected during runtime bootstrap)");
// portToOffsetMapping = new Dictionary<IPortModel, uint>();
// var cf = new ConstantEntity {Value = objectConstantModel.value};
// MapPort(portToOffsetMapping, objectConstantModel.OutputPort, ref cf.ValuePort.Port, nodeId);
// node = cf;
// return;
}
default:
throw new NotImplementedException();
}
}
protected override Type Visit(ConstantString con) => Type.String;
protected override BaseExpression Visit(ConstantString con)
{
_constantCount.AddOrUpdate(new Value(con.Value), 1, (_, a) => a + 1);
return(base.Visit(con));
}
protected override IEnumerable <BaseStatement> Visit(ConstantString con) => new[] { new Assignment(MkTmp(), con) };
private void CreateMenuList()
{
MenuItemList = new MvxObservableCollection <string>(ConstantString.GetMenuItemList(GetSelectedRole()));
}
protected override BaseExpression Visit(ConstantString con)
{
using (AppendLine("\"" + con.Value + "\""))
return(base.Visit(con));
}
[NotNull] protected virtual BaseExpression Visit([NotNull] ConstantString con)
{
return(con);
}
public void DocumentNode(SearcherItem searcherItem, INodeModel nodeModel)
{
INode node;
switch (nodeModel)
{
case IDotsNodeModel baseDotsNodeModel:
node = baseDotsNodeModel.Node;
break;
case StringConstantModel _:
node = new ConstantString();
break;
case BooleanConstantNodeModel _:
node = new ConstantBool();
break;
case IntConstantModel _:
node = new ConstantInt();
break;
case FloatConstantModel _:
node = new ConstantFloat();
break;
case Vector2ConstantModel _:
node = new ConstantFloat2();
break;
case Vector3ConstantModel _:
node = new ConstantFloat3();
break;
case Vector4ConstantModel _:
node = new ConstantFloat4();
break;
case QuaternionConstantModel _:
node = new ConstantQuaternion();
break;
default:
return;
}
var nodeType = node.GetType();
var executionType = GetNodeExecutionType(nodeType, node);
var title = Attribute.IsDefined(node.GetType(), typeof(WorkInProgressAttribute))
? $"{searcherItem.Name} [WIP]"
: searcherItem.Name;
SectionTitle(title, 1);
var nodeDescription = GetNodeDescription(nodeType, executionType, out string exampleText, out string dataSetup);
if (!String.IsNullOrEmpty(nodeDescription))
{
Paragraph(nodeDescription);
}
GetPortsDescription(executionType, node);
if (exampleText != null)
{
SectionTitle("Examples", 2);
Paragraph(exampleText);
}
if (dataSetup != null)
{
SectionTitle("Data Setup", 2);
Paragraph(dataSetup);
}
}
protected override bool Visit(ConstantString con) => false;
[NotNull] protected abstract TResult Visit([NotNull] ConstantString con);
public void AddConstantString(ConstantString constantString)
{
constantStrings.Add(constantString);
router.Add(constantStrings.Count);
}
public void IsConstant()
{
var str = new ConstantString("str");
Assert.IsTrue(str.IsConstant);
}
