private int ParseObject(int index, WrapperObject parentNode) { parentNode.Value = new List <WrapperType>(); while (this.TokenList[index] != "}") { string valueName = string.Empty; index = RulesUtility.ValidateToken(this.TokenList[index], "\"", "Invalid Token. Need first double quote for string value", index); valueName = this.TokenList[index++]; index = RulesUtility.ValidateToken(this.TokenList[index], "\"", "Invalid Token. Need first double quote for string value", index); index = RulesUtility.ValidateToken(this.TokenList[index], ":", "Invalid Token. Need \":\" for divider of value", index); index = ParseValue(index, valueName, parentNode); if (this.TokenList[index] == ",") { index++; } else if (this.TokenList[index] == "}") { // will cancel out } else { throw new Exception("Invalid Token. Need last double quote for name of value"); } } return(index); }
private int AddHeader(int index) { var otherHeaders = new WrapperObject("HEADERS"); while (this.TokenList[index].ToLower() != "namespace") { if (this.TokenList[index].ToLower() == "using") { index++; if (this.TokenList[index].ToLower() == "system") { while (this.TokenList[index] != ";") { index++; } } else { string location = string.Empty; while (this.TokenList[index] != ";") { location += this.TokenList[index++]; } otherHeaders.Value.Add(new WrapperString("IMPORT", location)); } } index++; } this.Structure.Add(otherHeaders); return(index); }
private int AddClassLikeType(int index, WrapperObject wrapperObject, WrapperObject parentObject, string flag) { index = RulesUtility.ValidateToken(this.TokenList[index], flag, $"This is not an accurate {flag}.", index); while (this.TokenList[index] != "{") { wrapperObject.WrapperName += this.TokenList[index++]; } index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This is an invalid class opener.", index); switch (flag) { case "enum": index = BuildEnumContent(index, wrapperObject); break; case "class": index = BuildClassContent(index, wrapperObject); break; default: throw new Exception($"Unable to make a enum, struct, or class with this token {flag}."); } index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This is an invalid class closer.", index); parentObject.Value.Add(wrapperObject); return(index); }
public void Copy <TType>(WrapperObject <TType> wrapper) where TType : SuperObject { if (wrapper._justATestField is T tField) { _justATestField = tField; } }
public WrapperObject <SuperObject> GetBaseWrapper() { var baseWrapper = new WrapperObject <SuperObject>(); baseWrapper.Copy(this); return(baseWrapper); }
private int BuildClassProperty(int index, WrapperObject contentObject) { if (this.TokenList[index] == ";") { index = RulesUtility.ValidateToken(this.TokenList[index], ";", "This needs is a valid \';\'.", index); return(index); } var type = (WrapperString)contentObject.GetValue("VALUE_TYPE"); string statement = $"{type.Value} {contentObject.WrapperName} "; while (this.TokenList[index] != ";") { string lookAhead = this.TokenList[index + 1]; statement += this.TokenList[index]; if (lookAhead != "." && lookAhead != "(" && lookAhead != ")" && lookAhead != "\'" && lookAhead != ";" && this.TokenList[index] != "." && this.TokenList[index] != "(" && this.TokenList[index] != ")" && this.TokenList[index] != "\"" && this.TokenList[index] != "\'") { statement += " "; } index++; } index = RulesUtility.ValidateToken(this.TokenList[index], ";", "This needs is a valid \';\'.", index); contentObject.Value.Add(new WrapperString("STATEMENT_1", statement)); return(index); }
private int BuildEnumContent(int index, WrapperObject enumObject) { int times = 0; WrapperObject enumContent = new WrapperObject("ENUM_CONTENT"); while (this.TokenList[index] != "}") { WrapperString enumEntry = new WrapperString($"ENUM_VALUE_{times++}", string.Empty); while (this.TokenList[index] != "}" && this.TokenList[index] != ",") { enumEntry.Value += this.TokenList[index++]; } enumContent.Value.Add(enumEntry); if (this.TokenList[index] != "}") { index = RulesUtility.ValidateToken(this.TokenList[index], ",", $"{enumObject.WrapperName} enum object needs a valid divider.", index); } } enumObject.Value.Add(enumContent); return(index); }
private int FillConditionalStatement(int index, WrapperObject wrapperObject) { string conditionStatement = string.Empty; var values = string.Empty; index = RulesUtility.ValidateToken(this.TokenList[index], "(", "This needs is a valid \'(\'.", index); conditionStatement += "("; while (this.TokenList[index] != ")") { string lookAhead = this.TokenList[index + 1]; values += this.TokenList[index]; if (lookAhead != "." && lookAhead != "(" && lookAhead != ")" && lookAhead != "\'" && lookAhead != ";" && this.TokenList[index] != "." && this.TokenList[index] != "(" && this.TokenList[index] != ")" && this.TokenList[index] != "\"" && this.TokenList[index] != "\'") { values += " "; } index++; } conditionStatement += values; index = RulesUtility.ValidateToken(this.TokenList[index], ")", "This needs is a valid \')\'.", index); conditionStatement += ")"; wrapperObject.Value.Add(new WrapperString("CONDITION_STATEMENT", conditionStatement)); return(index); }
private void ConnectWeighingMachineService() { grdContainer.BlockUI(); mBolWeighingMachineLoaded = false; try { mObjWeighingMachineServer = (WeighingMachineServerObject)Activator.GetObject(typeof(WeighingMachineServerObject), "http://localhost:8810/WeighingMachine"); mObjWrapperObject = new WrapperObject(); mObjWeighingMachineServer.DataReceived += new WeighingMachineEventHandler(mObjWrapperObject.WrapperOnDataReceived); mObjWrapperObject.WrapperDataReceived += new WeighingMachineEventHandler(OnDataReceived); mObjWeighingMachineConnection = mObjWeighingMachineServer.Connect(); mBolWeighingMachineLoaded = true; } catch (Exception lObjException) { grdContainer.UnblockUI(); ShowMessage("Error", lObjException.Message); mBolWeighingMachineLoaded = false; } finally { grdContainer.UnblockUI(); } }
public void Callsite_ElementBinding_Functions_UniqueIds_ForReplicationOfInnerAndOuterFunction() { WrapperObject.ResetNextID(); var ws = Open <HomeWorkspaceModel>(TestDirectory, callsiteDir, "func_nested_replication.dyn"); BeginRun(); AssertPreviewValue("22e0f3229b314aa48914e8f6b925872c", Enumerable.Range(1, 3).ToList()); // this node currently rebinds to its inner callsites so there are repeated values being returned. // it's not clear this behavior is correct, but it matches expected results with zeroTouch nodes nested in // other zero touch nodes which access trace. This test is created to note the current behavior and to // alert us if it changes. AssertPreviewValue("74cd0ca6d4964ec2b500fbe96139d28c", new int[][] { new int[] { 4 }, new int[] { 4, 5 }, new int[] { 4, 5, 6 }, new int[] { 4, 5, 6, 7 } }); /* * AssertPreviewValue("74cd0ca6d4964ec2b500fbe96139d28c", new int[][] { * new int[] {4}, * new int[] {5,6 }, * new int[]{7,8,9 }, * new int[]{10,11,12,13 } * }); */ }
private int FillDoWhile(int index, WrapperObject doObject) { WrapperObject doContentObject = new WrapperObject("DO_CONTENT"); index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); index = this.FillFunctionContent(index, doContentObject); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); WrapperString whileCond = new WrapperString("WHILE_COND", string.Empty); index = RulesUtility.ValidateToken(this.TokenList[index], "while", "This needs is a valid \'while\'.", index); while (this.TokenList[index] != ")") { string lookAhead = this.TokenList[index + 1]; whileCond.Value += this.TokenList[index]; if (lookAhead != "." && lookAhead != "(" && lookAhead != ")" && lookAhead != "\'" && lookAhead != ";" && this.TokenList[index] != "." && this.TokenList[index] != "(" && this.TokenList[index] != ")" && this.TokenList[index] != "\"" && this.TokenList[index] != "\'") { whileCond.Value += " "; } index++; } index = RulesUtility.ValidateToken(this.TokenList[index], ")", "This needs is a valid \')\'.", index); whileCond.Value += ")"; index = RulesUtility.ValidateToken(this.TokenList[index], ";", "This needs is a valid \';\'.", index); whileCond.Value += ";"; doObject.Value.Add(doContentObject); doObject.Value.Add(whileCond); return(index); }
private int FillTryCatch(int index, WrapperObject mainTryObject) { WrapperObject tryBlockObject = new WrapperObject("TRY_CONTENT"); index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); index = this.FillFunctionContent(index, tryBlockObject); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); mainTryObject.Value.Add(tryBlockObject); if (this.TokenList[index] == "catch") { WrapperObject catchBlockObject = new WrapperObject("CATCH_CONTENT"); index = RulesUtility.ValidateToken(this.TokenList[index], "catch", "This needs is a valid \'catch\'.", index); if (this.TokenList[index] == "(") { string exStatement = string.Empty; while (this.TokenList[index] != ")") { string lookAhead = this.TokenList[index + 1]; exStatement += this.TokenList[index]; if (lookAhead != "." && lookAhead != "(" && lookAhead != ")" && lookAhead != "\'" && lookAhead != ";" && this.TokenList[index] != "." && this.TokenList[index] != "(" && this.TokenList[index] != ")" && this.TokenList[index] != "\"" && this.TokenList[index] != "\'") { exStatement += " "; } index++; } index = RulesUtility.ValidateToken(this.TokenList[index], ")", "This needs is a valid \')\'.", index); exStatement += ")"; catchBlockObject.Value.Add(new WrapperString("CATCH_COND", exStatement)); } index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); index = this.FillFunctionContent(index, catchBlockObject); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); mainTryObject.Value.Add(catchBlockObject); } if (this.TokenList[index] == "finally") { WrapperObject finallyObject = new WrapperObject("FINALLY_CONTENT"); index = RulesUtility.ValidateToken(this.TokenList[index], "finally", "This needs is a valid \'finally\'.", index); index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); index = this.FillFunctionContent(index, finallyObject); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); mainTryObject.Value.Add(finallyObject); } return(index); }
public void Callsite_ElementBinding_ShouldReturnUniqueIds() { WrapperObject.ResetNextID(); var ws = Open <HomeWorkspaceModel>(TestDirectory, callsiteDir, "nonNestedWorking_replication.dyn"); BeginRun(); AssertPreviewValue("a74679f905fc4883bb017851d94ac074", Enumerable.Range(1, 6).ToList()); }
public void Callsite_ElementBinding_CustomNodes_ShouldReturnUniqueIds() { WrapperObject.ResetNextID(); var ws = Open <HomeWorkspaceModel>(TestDirectory, callsiteDir, "element_binding_customNodes_replication.dyn"); BeginRun(); AssertPreviewValue("3cab31e7c7e646cfb11f6145edf1d8c3", Enumerable.Range(1, 6).ToList()); }
private int ParseValue(int index, string valueName, WrapperObject parentNode) { WrapperType actualValue; if (this.TokenList[index].Contains(".")) { var proposedDouble = this.TokenList[index].Split("."); if (int.TryParse(proposedDouble[0], out _) && int.TryParse(proposedDouble[1], out _)) { actualValue = new WrapperDouble(valueName, double.Parse(this.TokenList[index++])); } else { actualValue = new WrapperString(valueName, this.TokenList[index++]); } } else if (int.TryParse(this.TokenList[index], out _)) { actualValue = new WrapperInt(valueName, int.Parse(this.TokenList[index++])); } else if (this.TokenList[index].ToLower() == "true" || this.TokenList[index].ToLower() == "false") { bool boolVal = bool.Parse(this.TokenList[index++]); actualValue = new WrapperBool(valueName, boolVal); } else if (this.TokenList[index] == "<") { if (valueName.ToLower().Contains("array")) { actualValue = new WrapperArray(valueName, null); index = ParseArray(index, actualValue as WrapperArray); } else { actualValue = new WrapperObject(valueName, null); index = ParseObject(index, actualValue as WrapperObject); } } else { actualValue = new WrapperString(valueName, this.TokenList[index++]); } index = RulesUtility.ValidateToken(this.TokenList[index], "<", "Invalid Token. Need \'<\' for name of value", index); if (valueName.ToLower().Contains("array")) { index = RulesUtility.ValidateToken(this.TokenList[index], $"/{valueName.ToLower()}", $"Invalid Token. Need closing name {valueName} for name of value", index); } else { index = RulesUtility.ValidateToken(this.TokenList[index], $"/{valueName}", $"Invalid Token. Need closing name {valueName} for name of value", index); } index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need \'>\' for name of value", index); parentNode.Value.Add(actualValue); return(index); }
private int FillBracketStatement(int index, WrapperObject wrapperObject) { index = this.FillConditionalStatement(index, wrapperObject); index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); index = this.FillFunctionContent(index, wrapperObject); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); return(index); }
private int BuildFunction(int index, WrapperObject functionObject, bool isStruct) { int holderValue = 1; WrapperObject parameters = new WrapperObject("PARAMETERS"); index = RulesUtility.ValidateToken(this.TokenList[index], "(", "This needs is a valid \'(\'.", index); while (this.TokenList[index] != ")") { WrapperObject parameter = new WrapperObject($"PARAMETER_{holderValue++}"); if (RulesUtility.IsValidType(this.ProgramTypeLanguage, this.TokenList[index])) { string valueName = this.TokenList[index++]; if (this.TokenList[index] == "[") { valueName += "[]"; index += 2; } parameter.Value.Add(new WrapperString("VALUE_TYPE", valueName)); parameter.Value.Add(new WrapperString("PARAM_NAME", this.TokenList[index++])); if (this.TokenList[index] == ")") { parameters.Value.Add(parameter); break; } index = RulesUtility.ValidateToken(this.TokenList[index], ",", "This needs is a valid \',\'.", index); } else { throw new Exception("This is an invalid parameter type."); } parameters.Value.Add(parameter); } if (isStruct && parameters.Value.Count < 0) { throw new Exception("You cannot have a default constructor for a struct object."); } else if (parameters.Value.Count > 0) { functionObject.Value.Add(parameters); } index = RulesUtility.ValidateToken(this.TokenList[index], ")", "This needs is a valid \')\'.", index); index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); WrapperObject functionContent = new WrapperObject("FUNCTION_CONTENT"); index = this.FillFunctionContent(index, functionContent); functionObject.Value.Add(functionContent); index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); return(index); }
private int BuildAutoProperty(int index, WrapperObject contentObject, WrapperObject parentObject) { index = RulesUtility.ValidateToken(this.TokenList[index], "{", "This needs is a valid \'{\'.", index); WrapperObject setObject = new WrapperObject("SET"); WrapperObject getObject = new WrapperObject("GET"); contentObject.CopyData(getObject); contentObject.CopyData(setObject); string compVariableName = "_" + char.ToLower(contentObject.WrapperName[0]).ToString() + contentObject.WrapperName.Substring(1); string holdOlderName = contentObject.WrapperName; if (!parentObject.GetKeys().Contains(compVariableName)) { contentObject.WrapperName = compVariableName; contentObject.UpdateStringValue("ACCESS_MOD", "private"); parentObject.Value.Add(contentObject); } WrapperString valueType = setObject.GetValue("VALUE_TYPE") as WrapperString; WrapperObject parameters = new WrapperObject("PARAMETERS"); WrapperObject parameter = new WrapperObject($"PARAMETER_1"); parameter.Value.Add(new WrapperString("VALUE_TYPE", valueType.Value)); parameter.Value.Add(new WrapperString("PARAM_NAME", "value")); setObject.UpdateStringValue("VALUE_TYPE", "void"); parameters.Value.Add(parameter); setObject.Value.Add(parameters); if (this.TokenList[index] == "get") { index = this.BuildAuxMethod(index, getObject, compVariableName); index = this.BuildAuxMethod(index, setObject, compVariableName); } else if (this.TokenList[index] == "set") { index = this.BuildAuxMethod(index, setObject, compVariableName); index = this.BuildAuxMethod(index, getObject, compVariableName); } else { throw new Exception("This auto property needs an explicet get and set keywords."); } index = RulesUtility.ValidateToken(this.TokenList[index], "}", "This needs is a valid \'}\'.", index); getObject.WrapperName = $"Get{holdOlderName}"; setObject.WrapperName = $"Set{holdOlderName}"; parentObject.Value.Add(getObject); parentObject.Value.Add(setObject); this._autoPropertyList.Add(holdOlderName); this._autoPropertyList.Add($"this.{holdOlderName}"); return(index); }
private void BuildObject(WrapperObject mainNode, string tabs) { if (mainNode.WrapperName != string.Empty) { this.Results += $"{tabs}\"{mainNode.WrapperName}\": {{\n"; } for (int index = 0; index < mainNode.Value.Count; index++) { var node = mainNode.Value[index]; switch (node) { case WrapperArray wrapperArray: BuildArray(wrapperArray, tabs + "\t"); break; case WrapperObject wrapperObject: BuildObject(wrapperObject, tabs + "\t"); break; case WrapperBool wrapperBool: this.Results += $"{tabs + "\t"}\"{wrapperBool.WrapperName}\": {wrapperBool.Value.ToString().ToLower()}"; break; case WrapperDouble wrapperDouble: this.Results += $"{tabs + "\t"}\"{wrapperDouble.WrapperName}\": {wrapperDouble.Value}"; break; case WrapperInt wrapperInt: this.Results += $"{tabs + "\t"}\"{wrapperInt.WrapperName}\": {wrapperInt.Value}"; break; case WrapperString wrapperString: this.Results += $"{tabs + "\t"}\"{wrapperString.WrapperName}\": \"{wrapperString.Value}\""; break; default: throw new Exception("This type is invalid for build the file."); } if (index != mainNode.Value.Count - 1) { this.Results += ",\n"; } else { this.Results += "\n"; } } if (mainNode.WrapperName != string.Empty) { this.Results += $"{tabs}}}"; } }
private int ParseValue(int index, string valueName, WrapperObject parentNode) { WrapperType actualValue = null; if (this.TokenList[index].Contains("\"")) { index = RulesUtility.ValidateToken(this.TokenList[index], "\"", "Invalid Token. Need first double quote for string value", index); actualValue = new WrapperString(valueName, this.TokenList[index++]); index = RulesUtility.ValidateToken(this.TokenList[index], "\"", "Invalid Token. Need first double quote for string value", index); } else if (this.TokenList[index].Contains(".")) { var proposedDouble = this.TokenList[index].Split("."); if (int.TryParse(proposedDouble[0], out _) && int.TryParse(proposedDouble[1], out _)) { actualValue = new WrapperDouble(valueName, double.Parse(this.TokenList[index++])); } else { throw new Exception("This is an invlid Double Value"); } } else if (int.TryParse(this.TokenList[index], out _)) { actualValue = new WrapperInt(valueName, int.Parse(this.TokenList[index++])); } else if (this.TokenList[index] == "true" || this.TokenList[index] == "false") { bool boolVal = bool.Parse(this.TokenList[index++]); actualValue = new WrapperBool(valueName, boolVal); } else if (this.TokenList[index] == "{") { index++; actualValue = new WrapperObject(valueName, null); index = ParseObject(index, actualValue as WrapperObject); index++; } else if (this.TokenList[index] == "[") { index++; actualValue = new WrapperArray(valueName, null); index = ParseArray(index, actualValue as WrapperArray); index++; } parentNode.Value.Add(actualValue); return(index); }
private int Start(int index) { WrapperObject wholeFile = new WrapperObject("WHOLE_FILE"); while (index < this.TokenList.Count) { WrapperObject potentialObject = new WrapperObject(); if (RulesUtility.ValidAccessModifiers(this.ProgramTypeLanguage, this.TokenList[index])) { potentialObject.Value.Add(new WrapperString("ACCESS_MOD", this.TokenList[index++].ToLower())); } else { potentialObject.Value.Add(new WrapperString("ACCESS_MOD", "public")); } if (this.TokenList[index].ToLower() == "static") { potentialObject.Value.Add(new WrapperBool("IS_STATIC", true)); index++; } else if (this.TokenList[index].ToLower() == "enum") { index = this.AddClassLikeType(index, potentialObject, wholeFile, "enum"); continue; } else { potentialObject.Value.Add(new WrapperBool("IS_STATIC", false)); } if (this._isOneClass) { throw new Exception("Java does not allow multiple classes. Please seperate classes into individual files."); } else { this._isOneClass = true; } index = this.AddClassLikeType(index, potentialObject, wholeFile, "class"); } this.Structure.Add(wholeFile); this._isOneClass = false; return(index); }
public void Callsite_ElementBinding_CustomNodes2dReplication_ShouldReturnUniqueIds() { WrapperObject.ResetNextID(); var ws = Open <HomeWorkspaceModel>(TestDirectory, callsiteDir, "element_binding_customNodes_replication2d.dyn"); BeginRun(); AssertPreviewValue("3cab31e7c7e646cfb11f6145edf1d8c3", new int[][] { new int[] { 1 }, new int[] { 2, 3 }, new int[] { 4, 5, 6 }, new int[] { 7, 8, 9, 10 }, new int[] { 11, 12, 13, 14, 15 }, new int[] { 16, 17, 18, 19, 20, 21 } }); }
public void OnResultExecuting(ResultExecutingContext context) { var result = context.Result; if (result is ObjectResult) { // wrap the inner object var newValue = new WrapperObject(result.Value); // replace the result context.Result = new ObjectResult(newValue) { // copy the status code StatusCode = result.StatusCode, }; } }
private int ParseArray(int index, WrapperArray parentNode) { parentNode.Value = new List <WrapperObject>(); int id = 0; while (this.TokenList[index] != "]") { index = RulesUtility.ValidateToken(this.TokenList[index], "{", "Need object for arrays", index); var actualValue = new WrapperObject(string.Format("ID-", id++), null); index = ParseObject(index, actualValue); index++; bool hasNoId = true; foreach (var new_id in actualValue.Value) { if (new_id.WrapperName.ToLower() == "id") { var tempNode = new_id as WrapperInt; actualValue.WrapperName = tempNode.WrapperName + "-" + tempNode.Value; hasNoId = false; break; } } if (hasNoId) { throw new Exception("Array entry has no valid id. Please place id value in Json."); } parentNode.Value.Add(actualValue); if (this.TokenList[index] == ",") { index++; } else if (this.TokenList[index] == "]") { // will cancel out } else { throw new Exception("Invalid Token. Need last double quote for name of value"); } } return(index); }
private int ParseObject(int index, WrapperObject parentNode) { parentNode.Value = new List <WrapperType>(); while (index < this.TokenList.Count) { index = RulesUtility.ValidateToken(this.TokenList[index], "<", "Invalid Token. Need \'<\' for name of value", index); if (this.TokenList[index] == $"/{parentNode.WrapperName}") { break; } string valueName = this.TokenList[index++]; index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need \'>\' for name of value", index); index = ParseValue(index, valueName, parentNode); } return(index - 1); }
private int AddHeader(int index) { var otherHeaders = new WrapperObject("HEADERS"); // TODO: make sure to implement this while multi file task while ((this.TokenList[index].ToLower() != "class" && this.TokenList[index].ToLower() != "enum") && !RulesUtility.ValidAccessModifiers(this.ProgramTypeLanguage, this.TokenList[index])) { if (this.TokenList[index].ToLower() == "import") { index++; if (this.TokenList[index].ToLower() == "java") { while (this.TokenList[index] != ";") { index++; } } else { string location = string.Empty; while (this.TokenList[index] != ";") { location += this.TokenList[index++]; } otherHeaders.Value.Add(new WrapperString("IMPORT", location)); } } else if (this.TokenList[index].ToLower() == "package") { index = RulesUtility.ValidateToken(this.TokenList[index], "package", "This is not an accurate package.", index); string packageName = string.Empty; while (this.TokenList[index] != ";") { packageName += this.TokenList[index++]; } otherHeaders.Value.Add(new WrapperString("PACKAGE", packageName)); } index++; } this.Structure.Add(otherHeaders); return(index); }
public string Serialize(IEnumerable <Suggestion> suggestions) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(WrapperObject)); using (MemoryStream ms = new MemoryStream()) { WrapperObject wrapperObject = new WrapperObject { Suggestions = suggestions }; serializer.WriteObject(ms, wrapperObject); ms.Position = 0; using (StreamReader sr = new StreamReader(ms)) { return(sr.ReadToEnd()); } } }
public override void ParseFile() { Log.Info("Starting to Parse XML file."); WrapperType mainNode; int index = 0; index = VerifyHeader(index); if (this.TokenList[index] == "<") { index++; if (this.TokenList[index].Contains("Array")) { mainNode = new WrapperArray(this.TokenList[index++], null); index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need first double quote for name of value", index); index = ParseArray(index, mainNode as WrapperArray); index = RulesUtility.ValidateToken(this.TokenList[index], "<", "Invalid Token. Need \'<\' for name of value", index); index = RulesUtility.ValidateToken(this.TokenList[index], $"/{mainNode.WrapperName + "Array"}", $"Invalid Token. Need closing name {mainNode.WrapperName} for name of value", index); index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need \'>\' for name of value", index); } else { mainNode = new WrapperObject(this.TokenList[index++], null); index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need first double quote for name of value", index); index = ParseObject(index, mainNode as WrapperObject); index = RulesUtility.ValidateToken(this.TokenList[index], "<", "Invalid Token. Need \'<\' for name of value", index); index = RulesUtility.ValidateToken(this.TokenList[index], $"/{mainNode.WrapperName}", $"Invalid Token. Need closing name {mainNode.WrapperName} for name of value", index); index = RulesUtility.ValidateToken(this.TokenList[index], ">", "Invalid Token. Need \'>\' for name of value", index); } } else { throw new Exception("Invalid start to XML Parsing."); } this.Structure.Add(mainNode); Log.Success("XML Parse Successfully Completed."); }
private void BuildObject(WrapperObject mainNode, string tabs) { this.Results += $"{tabs}<{mainNode.WrapperName}>\n"; foreach (var node in mainNode.Value) { if (node.WrapperName.ToLower() == "id") { continue; } switch (node) { case WrapperArray wrapperArray: BuildArray(wrapperArray, tabs + " "); break; case WrapperObject wrapperObject: BuildObject(wrapperObject, tabs + " "); break; case WrapperBool wrapperBool: this.Results += $"{tabs + " "}<{wrapperBool.WrapperName}>{wrapperBool.Value}</{wrapperBool.WrapperName}>\n"; break; case WrapperDouble wrapperDouble: this.Results += $"{tabs + " "}<{wrapperDouble.WrapperName}>{wrapperDouble.Value}</{wrapperDouble.WrapperName}>\n"; break; case WrapperInt wrapperInt: this.Results += $"{tabs + " "}<{wrapperInt.WrapperName}>{wrapperInt.Value}</{wrapperInt.WrapperName}>\n"; break; case WrapperString wrapperString: this.Results += $"{tabs + " "}<{wrapperString.WrapperName}>{wrapperString.Value}</{wrapperString.WrapperName}>\n"; break; default: throw new Exception("This type is invalid for build the file."); } } this.Results += $"{tabs}</{mainNode.WrapperName}>\n"; }
public void Callsite_ElementBinding_CustomNodes_MultipleRunsShouldResetInvocationCount() { WrapperObject.ResetNextID(); var ws = Open <HomeWorkspaceModel>(TestDirectory, callsiteDir, "element_binding_customNodes_replication.dyn"); BeginRun(); AssertPreviewValue("3cab31e7c7e646cfb11f6145edf1d8c3", Enumerable.Range(1, 6).ToList()); //grab the inner callsite inside the custom node var callsite = this.CurrentDynamoModel.EngineController.LiveRunnerRuntimeCore.RuntimeData.CallsiteCache. Where(kv => kv.Key.Contains("WrapperObject")).FirstOrDefault().Value; //should have executed 6 times Assert.AreEqual(callsite.invokeCount, 6); //force a re execution and if binding succeeds then data should be unchanged. ws.Nodes.OfType <CodeBlockNodeModel>().First().SetCodeContent("5..10", ws.ElementResolver); AssertPreviewValue("3cab31e7c7e646cfb11f6145edf1d8c3", Enumerable.Range(1, 6).ToList()); //count should have been reset and invoked 6 more times Assert.AreEqual(callsite.invokeCount, 6); }
public bool IsUsed(WrapperObject container) { return NativeMethods.cgIsParameterUsed(this.Handle, container.Handle); }
public virtual WrapperObject ConvertToWraperObject(XmlDocument item) { WrapperObject obj = new WrapperObject(null); obj.MappingSettings = this.PipeSettings.Mappings; obj.Language = this.PipeSettings.LanguageIds.FirstOrDefault(); obj.AddProperty(PublishingConstants.FieldTitle, item.Title); obj.AddProperty(PublishingConstants.FieldContent, item.Content); obj.AddProperty(PublishingConstants.FieldItemHash, GenerateItemHash(item)); obj.AddProperty(PublishingConstants.FieldLink, item.Image); obj.AddProperty(PublishingConstants.FieldPublicationDate, item.Date); obj.AddProperty(PublishingConstants.FieldIdentifier, item.Id); obj.AddProperty(PublishingConstants.FieldCategories, item.Categories); //list of categories (Category.Name) separated by comma //obj.AddProperty(PublishingConstants.FieldCategories, "News"); return obj; }
protected override void SetPropertiesThroughPropertyDescriptor(IContent item, WrapperObject wrapperObj) { var properties = TypeDescriptor.GetProperties(wrapperObj); TaxonomyManager taxonomyManager = TaxonomyManager.GetManager(); foreach (PropertyDescriptor propertyValue in properties) { if (propertyValue.Name.Equals("Categories")) { //var Category = taxonomyManager.GetTaxa<HierarchicalTaxon>().Where(t => t.Taxonomy.Name == "Categories").FirstOrDefault(); //try //{ // (item as Telerik.Sitefinity.GenericContent.Model.Content).Organizer.AddTaxa("Category", Category.Id); //} //catch (Exception e){ //} var tagName = propertyValue.GetValue(wrapperObj).ToString(); var newtagname = tagName.Replace(" ", "").Replace("&", ""); var tagList = taxonomyManager.GetTaxa<HierarchicalTaxon>().Where(t => t.Name == newtagname); if (tagList.Any()) { (item as Telerik.Sitefinity.GenericContent.Model.Content).Organizer.AddTaxa("Category", tagList.FirstOrDefault().Id); } else { var catTaxonomy = taxonomyManager.GetTaxonomies<HierarchicalTaxonomy>().Where(t => t.Name == "Categories").SingleOrDefault(); var parentTaxonomy = taxonomyManager.GetTaxa<HierarchicalTaxon>().Where(t => t.Name == "News").Single(); var newCat = taxonomyManager.CreateTaxon<HierarchicalTaxon>(); newCat.Name = newtagname; newCat.Title = tagName; newCat.Description = ""; newCat.UrlName = newtagname; newCat.Taxonomy = catTaxonomy; parentTaxonomy.Subtaxa.Add(newCat); //taxonomyManager.GetTaxonomies<HierarchicalTaxonomy>().Where(t => t.Name == "news").First().Taxa.Add(newCat); taxonomyManager.SaveChanges(); tagList = taxonomyManager.GetTaxa<HierarchicalTaxon>().Where(t => t.Name == newtagname); (item as Telerik.Sitefinity.GenericContent.Model.Content).Organizer.AddTaxa("Category", tagList.FirstOrDefault().Id); } try { } catch (Exception e) { } } else { var propertyDescriptor = this.ContentItemTypeDescriptros.Find(propertyValue.Name, false); if (propertyDescriptor == null) continue; if (propertyDescriptor is LstringPropertyDescriptor) { // HACK - the property value can be Lstring, TextSyndicationContent or string in this case. var value = ""; if (propertyValue.GetValue(wrapperObj) is Lstring) { value = ((Lstring)propertyValue.GetValue(wrapperObj)).Value; } else { if (propertyValue.GetValue(wrapperObj) is TextSyndicationContent) { value = ((TextSyndicationContent)propertyValue.GetValue(wrapperObj)).Text; } else { value = (string)propertyValue.GetValue(wrapperObj); } } ((LstringPropertyDescriptor)propertyDescriptor).SetString(item, value, this.GetWrapperObjectCulture(wrapperObj)); continue; } if (!propertyDescriptor.IsReadOnly) { if (!propertyDescriptor.PropertyType.IsList() && !propertyDescriptor.PropertyType.IsCollection() && !propertyDescriptor.PropertyType.IsDictionary()) { (item as IDynamicFieldsContainer).SetValue(propertyValue.Name, propertyValue.GetValue(wrapperObj)); } } } } }