Exemplo n.º 1
0
 /*
  * Get package name from namespace uri, splitted at : / and . characters, in reverse order
 */
 public static string GetPackage(Namespace ns)
 {
     return ns.FullName;
     //string[] withoutprefix = GetUriWithSlash(ns).Split(new char[] { ':', '/', '.' });
     //string retVal = "";
     //for (int i = withoutprefix.Length - 2; ; i--)
     //{
     //    if (withoutprefix[i] == "")
     //    {
     //        break;
     //    }
     //    retVal += withoutprefix[i] + ".";
     //}
     //return retVal.Remove(retVal.Length - 1);
 }
Exemplo n.º 2
0
        public static void CreateOperationInputOutputTypes(Namespace ns)
        {
            foreach (Interface intf in ns.Declarations.OfType<Interface>())
            {
                foreach(Operation operation in intf.Operations)
                {
                    StructType inputType =
                        new StructType()
                        {
                            Name = operation.Name,
                            Namespace = intf.Namespace
                        };
                    foreach (OperationParameter param in operation.Parameters)
                    {
                        inputType.Fields.Add(
                            new StructField()
                            {
                                Name = param.Name,
                                Type = param.Type
                            });
                    }
                    StructType outputType =
                        new StructType()
                        {
                            Name = operation.Name + "Response",
                            Namespace = intf.Namespace
                        };
                    outputType.Fields.Add(
                        new StructField()
                        {
                            Name = operation.Name + "Result",
                            Type = operation.ReturnType
                        });

                    operation.InputType = inputType;
                    operation.OutputType = outputType;
                }
            }
        }
Exemplo n.º 3
0
 public List<string> Generated_GenerateExpressionHelper(Namespace ns)
 {
     List<string> __result = new List<string>();
         using(TemplatePrinter __printer = new TemplatePrinter(__result))
         {
             __printer.WriteTemplateOutput("^");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("package ");
             __printer.Write(Generated_GetPackage(ns).ToLower());
             __printer.WriteTemplateOutput(";");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("^");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("public interface ExpressionHelper<T> {");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("^");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("    T doWork();");
             __printer.WriteLine();
             __printer.WriteTemplateOutput("}");
             __printer.WriteLine();
         }
         return __result;
 }
Exemplo n.º 4
0
 protected void Error_NamespaceUri(ISourceLocation site, Namespace @namespace)
 {
     errorReporter.Error(site, "URI for namespace \"{0}\" is redefined.", @namespace.FullName);
 }
Exemplo n.º 5
0
 protected void Error_NamespaceImport(ISourceLocation site, Namespace @namespace)
 {
     errorReporter.Error(site, "Using namespace \"{0}\" is redundant.", @namespace.FullName);
 }
Exemplo n.º 6
0
 /*
  * Returns the not null Uri with slash at end
  */
 public static string GetUriWithSlash(Namespace ns)
 {
     return GetUri(ns).EndsWith("/") ? GetUri(ns) : GetUri(ns) + "/";
 }
Exemplo n.º 7
0
 /*
  * Returns Uri, if null returns http://default
 */
 public static string GetUri(Namespace ns)
 {
     if (ns.Uri == null)
         return "http://default";
     else
         return ns.Uri;
 }
Exemplo n.º 8
0
        /// <summary>
        /// Processes one identifier of a dotted namespace name.
        /// </summary>
        /// <remarks>
        /// The method is called recursively until only the last identifier remains.
        /// </remarks>
        /// <param name="identifiers">The list of identifiers.</param>
        /// <param name="scope">The parent namespace to search next identifier in.</param>
        /// <returns>The namespace that the list identifies.</returns>
        private Namespace Process_NamespaceReference(List<string> identifiers, SoaObject scope)
        {
            Namespace @namespace = null;
            try
            {
                // Try to find the namespace identified by the first of the remaining name parts
                @namespace = (Namespace)NameContext.ResolveName(scope, identifiers[0], typeof(Namespace));
            }
            catch (NameNotFoundException)
            {
                // If not found, create
                @namespace = new Namespace();
                @namespace.Name = identifiers[0];
                @namespace.Namespace = (Namespace)scope;
            }

            if (identifiers.Count == 1)
            {
                // If this is the last part, simply return it
                return @namespace;
            }
            else
            {
                // Otherwise continue searching/creating with the next part of the name
                identifiers.RemoveAt(0);
                return this.Process_NamespaceReference(identifiers, @namespace);
            }
        }
Exemplo n.º 9
0
 public string Generated_GetUriWithSlash(Namespace ns)
 {
     return GeneratorLibExtensions.GetUriWithSlash(ns);
 }
Exemplo n.º 10
0
 public string Generated_GetPackage(Namespace ns)
 {
     return GeneratorLibExtensions.GetPackage(ns);
 }
Exemplo n.º 11
0
        private void Read()
        {
            try
            {

                // Beolvasandó dokumentumok listája
                LinkedList<XDocument> documentList = new LinkedList<XDocument>();

                // Imprortálások bekérése
                XDocument doc = XDocument.Load(System.IO.Path.Combine(this.Path, this.FileName));

                // Rekurzív függvény az importálások kifejtésére
                CheckImports(documentList, doc, Path);

                //--------------------------------------------------------------------

                // Az összes fájl feldolgozása
                foreach (XDocument xd in documentList)
                {
                    XNamespace targetNS = "";
                    XNamespace defNS = "";
                    try
                    {
                        targetNS = (string)xd.Element("definitions").Attribute("targetNamespace");
                        defNS = "";
                    }
                    catch { }
                    try
                    {
                        targetNS = (string)xd.Element("schema").Attribute("targetNamespace");
                        defNS = "";
                    }
                    catch { }
                    try
                    {
                        targetNS = (string)xd.Element(xsdNS + "schema").Attribute("targetNamespace");
                        defNS = xsdNS;
                    }
                    catch { }
                    try
                    {
                        targetNS = (string)xd.Element(wsdlNS + "definitions").Attribute("targetNamespace");
                        defNS = wsdlNS;
                    }
                    catch { }

                    if (!nsDictionary.ContainsKey(targetNS))
                    {
                        Namespace myNs = new Namespace()
                        {
                            Name = "namespace" + fileCount.ToString(),
                            Uri = targetNS.NamespaceName
                        };

                        nsDictionary.Add(targetNS, myNs);
                        fileCount++;
                    }

                    // services
                    var services = from c in xd.Descendants(wsdlNS + "service")
                                   select c;

                    foreach (XElement xe in services)
                    {
                        StoreItem coll = new StoreItem()
                        {
                            name = (string)xe.Attribute("name"),
                            definition = xe,
                            objectType = StoreItemType.service,
                            ownNS = targetNS
                        };

                        store.Add(coll);
                    }

                    // binding
                    var bindings = from c in xd.Descendants(wsdlNS + "binding")
                                   select c;

                    foreach (XElement xe in bindings)
                    {
                        StoreItem coll = new StoreItem()
                        {
                            name = (string)xe.Attribute("name"),
                            definition = xe,
                            objectType = StoreItemType.binding,
                            ownNS = targetNS
                        };

                        store.Add(coll);
                    }

                    // porttype
                    var portTypes = from c in xd.Descendants(wsdlNS + "portType")
                                    select c;

                    foreach (XElement xe in portTypes)
                    {
                        StoreItem coll = new StoreItem()
                        {
                            name = (string)xe.Attribute("name"),
                            definition = xe,
                            objectType = StoreItemType.portType,
                            ownNS = targetNS
                        };

                        store.Add(coll);
                    }

                    // message
                    var messages = from c in xd.Descendants(wsdlNS + "message")
                                   select c;

                    foreach (XElement xe in messages)
                    {
                        StoreItem coll = new StoreItem()
                        {
                            name = (string)xe.Attribute("name"),
                            definition = xe,
                            objectType = StoreItemType.message,
                            ownNS = targetNS
                        };

                        store.Add(coll);
                    }

                    //TODO: <type> és <schema> ellenőrzése a targetNamespace miatt!!!
                    var schemas = from c in xd.Descendants(xsdNS + "schema")
                                  select c;

                    foreach (XElement schema in schemas)
                    {
                        targetNS = (string)schema.Attribute("targetNamespace");

                        if (!nsDictionary.ContainsKey(targetNS))
                        {
                            Namespace myxsdNs = new Namespace()
                            {
                                Name = "namespace" + fileCount.ToString(),
                                Uri = targetNS.NamespaceName
                            };

                            nsDictionary.Add(targetNS, myxsdNs);
                            fileCount++;
                        }

                        // simpleTypes
                        var simpleTypes = from c in schema.Elements(xsdNS + "simpleType")
                                          select c;
                        //var simpleTypes = from c in xd.Descendants(xsdNS + "simpleType")
                        //                  select c;

                        foreach (XElement xe in simpleTypes)
                        {
                            StoreItem coll = new StoreItem()
                            {
                                name = (string)xe.Attribute("name"),
                                definition = xe,
                                objectType = StoreItemType.enumType,
                                ownNS = targetNS
                            };

                            store.Add(coll);
                        }

                        // complexTypes
                        //var complexTypes = from c in xd.Descendants(xsdNS + "complexType")
                        //                   select c;
                        var complexTypes = from c in schema.Elements(xsdNS + "complexType")
                                           select c;

                        foreach (XElement xe in complexTypes)
                        {

                            StoreItem coll = new StoreItem()
                            {
                                name = (string)xe.Attribute("name"),
                                definition = xe,
                                objectType = StoreItemType.complexType,
                                ownNS = targetNS

                            };

                            store.Add(coll);
                        }

                        var elements = from c in schema.Elements(xsdNS + "element")
                                       select c;

                        foreach (XElement xe in elements)
                        {
                            if (xe.Attribute("type") != null)
                            {
                                StoreItem coll = new StoreItem()
                                {
                                    name = (string)xe.Attribute("name"),
                                    definition = xe,
                                    objectType = StoreItemType.unNamedElementType,
                                    ownNS = targetNS
                                };
                                //Wr(coll.name);
                                store.Add(coll);
                            }
                            else
                            {
                                XAttribute nameAttribute = xe.Attribute("name");
                                XElement cType = xe.Element(xsdNS + "complexType");
                                XElement modifiendXe = cType;
                                modifiendXe.Add(nameAttribute);
                                StoreItem coll = new StoreItem()
                                {
                                    name = (string)modifiendXe.Attribute("name"),
                                    definition = modifiendXe,
                                    objectType = StoreItemType.complexType,
                                    ownNS = targetNS
                                };
                                //Wr(coll.name);
                                store.Add(coll);
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                throw;
            }
        }