Free generate wsdl file software for linux

B::Generate is a Perl module which you can create your own op trees.


SYNOPSIS

use B::Generate;
# Do nothing, slowly.
CHECK {
my $null = new B::OP("null",0);
my $enter = new B::OP("enter",0);
my $cop = new B::COP(0, "hiya", 0);
my $leave = new B::LISTOP("leave", 0, $enter, $null);
$leave->children(3);
$enter->sibling($cop);
$enter->next($cop);
$cop->sibling($null);
$null->next($leave);
$cop->next($leave);

# Tell Perl where to find our tree.
B::main_root($leave);
B::main_start($enter);
}

WARNING

This module will create segmentation faults if you dont know how to use it properly. Further warning: sometimes I dont know how to use it properly.

There are lots of other methods and utility functions, but they are not documented here. This is deliberate, rather than just through laziness. You are expected to have read the Perl and XS sources to this module before attempting to do anything with it.
Patches welcome.

Malcolm Beatties B module allows you to examine the Perl op tree at runtime, in Perl space; its the basis of the Perl compiler. But what it doesnt let you do is manipulate that op tree: it wont let you create new ops, or modify old ones. Now you can.
Well, if youre intimately familiar with Perls internals, you can.

B::Generate turns Bs accessor methods into get-set methods. Hence, instead of merely saying

$op2 = $op->next;

you can now say

$op->next($op2);

to set the next op in the chain. It also adds constructor methods to create new ops. This is where it gets really hairy.

new B::OP ( type, flags )
new B::UNOP ( type, flags, first )
new B::BINOP ( type, flags, first, last )
new B::LOGOP ( type, flags, first, other )
new B::LISTOP ( type, flags, first, last )
new B::COP ( flags, name, first )

In all of the above constructors, type is either a numeric value representing the op type (62 is the addition operator, for instance) or the name of the op. ("add")
(Incidentally, if you know about custom ops and have registed them properly with the interpreter, you can create custom ops by name: new B::OP("mycustomop",0), or whatever.)

first, last and other are ops to be attached to the current op; these should be B::OP objects. If you havent created the ops yet, dont worry; give a false value, and fill them in later:

$x = new B::UNOP("negate", 0, undef);
# ... create some more ops ...
$x->first($y);

In addition, one may create a new nextstate operator with

newstate B::op ( flags, label, op)

in the same manner as B::COP::new - this will also, however, add the lineseq op.
Finally, you can set the main root and the starting op by passing ops to the B::main_root and B::main_start functions.

This module can obviously be used for all sorts of fun purposes. The best one will be in conjuction with source filters; have your source filter parse an input file in a foreign language, create an op tree for it and get Perl to execute it. Then email me and tell me how you did it. And why.

Data::Generate allows you to create various types of synthetic data by parsing "regex-like" data creation rules.

This module generates data by parsing given text statements (data creation rules). These statements are flexible and powerful regex-like way to control the production of synthetic data. Think about a program that instead of selecting data which matches a regex filter expression, produces it. For example, from the rule [a-c], the generator would produce the array a,b,c. The module works as following:

Specify data creation rules.
my $generator= Data::Generate::parse(VC(24) [0-9][2-3]);
At this step first you define one kind of output datatype (for ex. VC(24)= "output is a string with max length 24") and then with the rest of the expression define what it should look like. If parsing is successful a Data Generator object is instantiated.

Get data
my $Data= $generator->get_unique_data(10);
To really get the data, users must call the get_unique_data method by indicating the desired number of output values. The generator returns the values contained in an array reference. Please remark that output format is fixed according to the data type.

WSDL::Generator is a Perl module to generate wsdl file automagically.

SYNOPSIS

use WSDL::Generator;
my $wsdl = WSDL::Generator->new($init);
Foo->a_method($param};
print $wsdl->get(Foo);

You know folks out there who use another language than Perl (huh?) and you want to release a SOAP server for them

1/ thats very kind of you
2/ you need to generate a wsdl file
3/ this module can help

Because Perl is dynamically typed, it is a fantastic language to write SOAP clients, but that makes perl not-so-easy to use as SOAP server queried by statically typed languages such as Delphi, Java, C++, VB...

These languages need a WSDL file to communicate with your server.
The WSDL file contains all the data structure definition necessary to interact with the server.

It contains also the namespace and URL as well.

C++ WSDL Parser is an efficient C++ Web services library that includes a standards compliant WSDL parser API, a Schema parser and validator, an XML parser and serializer, and an API for dynamically inspecting and invoking WSDL Web services.
Enhancements:
- Many WSDLs can now be dynamically invoked.
- Added documentation (doxygen for the API).
- Better error reporting when types are found missing.

wsdlpull is a C++ WSDL Library. wsdlpull project includes a WSDL Parser , a XSD Schema
Parser and Validator and XML Parser and serializer and an API for dynamic WSDL inspection and invocation.
wsdlpull uses the xml pull api to parse a WSDL1.1 document. This makes wsdlpull highly efficient which is why you can process and invoke a WSDL in no time.
The parser provides APIs to access various WSDL elements such as operations,messages,bindings,port types. Although wsdlpull is based on the pull parsing style of xml parsing the API is meant to be semantically as close as possible to the standard API for parsing WSDL, namely WSDL4J.
The invocation API allows you to dynamically inspect and invoke a web service. Unlike other toolkits there is no need to generate stubs or type serializers. Writing a web service client involves providing the WSDL URL ,setting the operation ,the input types and getting back the results in just one step.
The schema parser and validator provides an API for parsing XSD schema documents and validating their xml instance documents. The schema parser is used to parse the types section of the WSDL document.
The Xml parser and serializer provide a C++ implementation of the XML Pull API . WSDL processing, XSD schema processing ,creating SOAP messages all use the parser and serializer.
Enhancements:
- Several new features were added, including the ability to validate multiple occurences of choice elements, a new -p option to print port types of a wsdl, a -g option in the wsdl tool to generate soap message, and an experimental -g option in the schema tool to generate instances.
- Fixes were also made for a schema:import bug and for a type reference in an imported schema which is defined in same wsdl file but under another namespace.

Pod::WSDL is a Perl module that creates WSDL documents from (extended) pod.

SYNOPSIS

use Pod::WSDL;

my $pod = new Pod::WSDL(source => My::Server,
location => http://localhost/My/Server,
pretty => 1,
withDocumentation => 1);

print $pod->WSDL;

Parsing the pod

How does Pod::WSDL work? If you instantiate a Pod::WSDL object with the name of the module (or the path of the file, or an open filehandle) providing the web service like this

my $pwsdl = new Pod::WSDL(source => My::Module,
location => http://my.services.location/on/the/web);

Pod::WSDL will try to find My::Module in @INC, open the file, parse it for WSDL directives and prepare the information for WSDL output. By calling

$pwsdl->WSDL;

Pod::WSDL will output the WSDL document. Thats it.
When using Pod::WSDL, the parser expects you to do the following:

Put the pod directly above the subroutines which the web services client is going to call. There may be whitespace between the pod and the sub declaration but nothing else.
Use the =begin/=end respectively the =for directives according to standard pod: anything between =begin WSDL and =end will be treated as pod. Anything composing a paragraph together with =for WSDL will be treated as pod.

Any subroutine not preceeded by WSDL pod will be left unmentioned. Any standard pod will be ignored (though, for an exception to this, see the section on own complex types below).

The individual instructions for Pod::WSDL always begin with a keyword, like _RETURN or _DOC or _FAULT. After this different things may follow, according to the specific type of instruction. The instruction may take one or more lines - everything up to the next line beginning with a keyword or the end of the pod is belonging to the current instruction.

Describing Methods

How do we use Pod::WSDL? In describing a web services method we have to say something about parameters, return values and faults. In addition you might want to add some documentation to these items and to the method itself.