RECORDMYDESKTOP(1) RECORDMYDESKTOP(1) NAME recordMyDesktop - record desktop sessions to an Ogg-Theora-Vorbis file. SYNOPSIS recordmydesktop [ Options ]^ filename DESCRIPTION recordMyDesktop produces a file(default out.ogv) that contains a video and audio recording of a linux desktop session. The default behavior of recording is to mark areas that have changed(through libxdamage) and update the frame. This behavior can be changed (option --full-shots ) to produce a more accurate result or capture windows that do not generate events on change(windows with accelerated 3d context) but this will notably increase the workload. recordMyDesktop doesn't have a commandline interface. After startup, it can be controled only through the following signals: SIGUSR1 causes the program to pause if it's currently recording, and vice-versa. SIGTERM causes normal termination of the recording. SIGINT also causes normal termination. SIGABRT terminates the program and removes the specified output file. This signals can also be delivered on the application, with the use of shortcuts. See --pause-shortcut and --stop-shortcut , on the Misc. section of Options bellow. A typical scenario of recording can be a command as simple as: ~$ recordmydesktop which will produce a fullscreen recording named out.ogv while a command like: ~$ recordmydesktop foo.ogv will write output to foo.ogv Since version 0.3, encoding will happen right after the recording fin‐ ishes. While this behavior saves a lot of CPU, you can revert to the old one by entering the --on-the-fly-encoding switch. To specify a region for recording you can type this: ~$ recordmydesktop -x X_pos -y Y_pos --width WIDTH --height HEIGHT -o foo.ogv where X_pos and Y_pos specify the offset in pixels from the upper left corner of your screen and WIDTH and HEIGHT the size of the window to be recorded(again in pixels). If the area extends beyond your current resolution, you will be notified appropriately and nothing will happen. Notice also, that if any option is entered you have to specify the output file with the -o switch. If you try to save under a filename that already exists, the name will be post-fixed with a number (incremented if that name exists already) To normally end a recording you can press ctl-c. (which will send a SIGINT to the program). For further manipulation of the end result look at the OPTIONS and NOTES sections. EXIT STATUS 0 is success Non-zero means an error occurred, which is printed in stderr. The following error codes indicate the nature of the error: 1 Error while parsing the arguments. 2 Initializing the encoder failed(either vorbis or theora). 3 Could not open/configure sound card. 4 Xdamage extension not present. 5 Shared memory extension not present. 6 Xfixes extension not present. 7 XInitThreads failed. 8 No $DISPLAY environment variable and none specified as argument. 9 Cannot connect to Xserver. 10 Color depth is not 32, 24 or 16bpp. 11 Improper window specification. 12 Cannot attach shared memory to proccess. 13 Cannot open file for writting. 14 Cannot load the Jack library ( UNUSED SINCE 0.3.8 ). 15 Cannot create new client. 16 Cannot activate client. 17 Port registration/connection failure. OPTIONS Generic Options: -h or --help Print help summary and exit. --version Print program version and exit. --print-config Print info about options selected during compilation and exit. Image Options: --windowid id_of_window id of window to be recorded. --display DISPLAY Display to connect to. -x X Offset in x direction. -y Y Offset in y direction. --width N Width of recorded window. --height N Height of recorded window. --dummy-cursor color Draw a dummy cursor, instead of the normal one.Value of color can be "black" or "white". --no-cursor Disable drawing of the cursor. --no-shared Disable usage of MIT-shared memory extension (Not Rec‐ ommended). --full-shots Take full screenshot at every frame(Not recomended!). --follow-mouse When this option is enabled, the capture area follows the mouse cursor. This is meaningfull only when the selected area is a subset of the full screen. This option auto-enables --full-shots. --quick-subsampling Do subsampling of the chroma planes by discarding extra pixels. --fps N(number>0.0) A positive number denoting desired framerate. Sound Options: --channels N(number>0) A positive number denoting desired sound channels in recording. --freq N(number>0) A positive number denoting desired sound frequency. --buffer-size N(number>0) A positive number denoting the desired sound buffer size(in frames, when using ALSA or OSS). --ring-buffer-size N(float number>0) A float number denoting the desired ring buffer size (in seconds,when using JACK only). The overall size of the buffer in bytes will be: ring_buffer_size * samplerate * number_of_ports * sizeof(jack_default_audio_sample_t), where sizeof(jack_default_audio_sample_t) is normally 4. --device SOUND_DEVICE Sound device(default hw:0,0 or /dev/dsp, depending on whether ALSA or OSS is used). --use-jack port1 port2... portn Record audio from the specified list of space-separated jack ports. When using this option, all the rest audio related ones(except --no-sound) are not taken into account. --no-sound Do not record sound. Encoding Options: --on-the-fly-encoding Encode the audio-video data, while recording. --v_quality n A number from 0 to 63 for desired encoded video qual‐ ity(default 63). --v_bitrate n A number from 45000 to 2000000 for desired encoded video bitrate(default 45000). --s_quality n Desired audio quality(-1 to 10). Misc Options: --rescue path_to_data Encode cache data from a previous session, into an Ogg/Theora+Vorbis file. The filename will be the one that was chosen ini‐ tially. Any other option specified with this one will be implicitly ignored and recordMyDesktop will exit after the end of the encoding. This option was added in recordMyDesktop 0.3.7 and it will not work with cache files produced from earlier versions. When using this option, remember that recordMyDesktop's cache is not safe, in respect to type-sizes and endianness. --print-config Print compilation time options. Currently prints whether Jack capture is enabled and if ALSA or OSS is used (may contain more information in the future). --no-wm-check When a 3d compositing window manager is detected the program will function as if the --full-shots option has been specified. This option disables that behavior alltogether. --no-frame Normally, around the recording area, there is drawn a frame to assist the user in identifying what does and what doesn't get captured. This frame will also follow around the mouse, when --follow-mouse is used. The frame might cause problems for drag and drop. If you do not wish this frame to appear, use this option. --pause-shortcut MOD+KEY Shortcut that will be used for pausing or unpausing the recording. MOD can be any combination of the following modifier keys: Control, Shift and Mod1 to Mod5. The modifiers can be separated with any character( except SPACE ) or none at all. KEY can be any key defined in /usr/include/X11/keysymdef.h without the XK_ prefix. The list of modifiers must be separated from the key with a plus('+') sign. Default is Control+Mod1+p (Mod1 usually corresponds to left Alt). --stop-shortcut MOD+KEY Shortcut that will be used to stop the recording. For more, see -pause-shortcut above. Default is Control+Mod1+s. --compress-cache Image data are cached with a light compression. --workdir DIR Location where a temporary directory will be created to hold project files(default /tmp). --delay n[H|h|M|m] Number of secs(default),minutes or hours before capture starts(number can be float). --overwrite If there is already a file with the same name, delete it. Default action is to add a number postfix to the new file. For example when not specifying a name, if out.ogv exists, the new file will be out-1.ogv and if that exists too, out-2.ogv and so on (no ad-infinitum though, more like ad-short- integer...) -o filename Name of recorded video(default out.ogv). If no other option is specified, filename can be given without the -o switch. USAGE recordmydesktop [OPTIONS]^filename ENVIRONMENT DISPLAY Display environment variable, specifying X server to con‐ nect to. NOTES Recording a window using the --windowid option, doesn't track the window itself, but the region that it covers. Also when using that option the -x,-y,--width and --height options are relative to the specified window area. An easy way to find out the id of a window, is by using the xwin‐ info program. Running a command like : xwininfo | awk ´/Window id:/ {print $4}´ will give you only the id of the window(which should look like this: 0x4800005) More conviniently you can put all that in the command that launches recordMyDesktop like this: ~$recordmydesktop --windowid $(xwininfo | awk ´/Window id:/ {print $4}´) Also, the lower quality you select on a video recording ( -v_quality option), the highest CPU-power that you will need. So if you are doing the encoding on the fly ,it's better to start with default values and manipulate the end-result with another program. An excellent converter is the vlc media player, which can perform a variety of transcoding operations, either using the graphical interface, or the command‐ line for more flexibility. vlc is a complex piece of software, so you should consult it's documentation, before using it. An example follows, which will resize a recording named out.ogv to 512x384: vlc -I dummy out.ogv vlc:quit --sout "#transcode{ vcodec = theo, width = 512, height = 384 }:duplicate{ dst = std{ access = file, mux=ogg, dst = \"out_512x384.ogv\" }}" If you wish to change the video quality you can append the --sout-theora-quality=n, with n in the range [1,10] e.g: vlc -I dummy out.ogv vlc:quit --sout "#transcode{ vcodec = theo, width = 512, height = 384 }:duplicate{ dst = std{ access = file, mux=ogg, dst = \"out_512x384.ogv\" }}" --sout-theora-quality=3 which will give a file of a video quality 18 (in a range of 0-63), thus appropriate for web-publishing. Another option is ffmpeg2theora , which despite its name is also a theora to theora converter. Changing the quality of a recordng with it, can be as simple as : ffmpeg2theora infile.ogv -v 3 -a 4 -o outfile.ogv It can even perform resizing on the size of the recording, or change the overall duration. BUGS Does not record 3d windows, if --full-shots isn't specified. Saving 65536 files with the same name, will result in upredictable behavior, which might manifest as an endless loop, or a segmentation fault. AUTHORS John<EMAIL_ADDRESS>SEE ALSO xwininfo(1) vlc(1) ffmpeg2theora(1) jack_lsp(1) Linux 13/7/2006 RECORDMYDESKTOP(1)


Available in Chrome 45+ | View Source | View on GitHub | Browse Samples
The Web Bluetooth
API discovers and communicates with devices over the Bluetooth 4 wireless
standard using the Generic Attribute Profile (GATT). It is currently only
partially implemented in Chrome OS and Android M behind the experimental flag
chrome://flags/#enable-web-bluetooth
. Check out all Web Bluetooth Samples.
This sample illustrates the use of the Web Bluetooth API to retrieve battery information from a nearby Bluetooth Device advertising Battery information with Bluetooth Low Energy. You may want to try this demo with the BLE Peripheral Simulator App from the Google Play Store.
function onButtonClick() {
'use strict';
log('Requesting Bluetooth Device...');
navigator.bluetooth.requestDevice(
{filters: [{services: ['battery_service']}]})
.then(device => {
log('> Found ' + device.name);
log('Connecting to GATT Server...');
return device.connectGATT();
})
.then(server => {
log('Getting Battery Service...');
return server.getPrimaryService('battery_service');
})
.then(service => {
log('Getting Battery Level Characteristic...');
return service.getCharacteristic('battery_level');
})
.then(characteristic => {
log('Reading Battery Level...');
return characteristic.readValue();
})
.then(buffer => {
let data = new DataView(buffer);
let batteryLevel = data.getUint8(0);
log('> Battery Level is ' + batteryLevel + '%');
})
.catch(error => {
log('Argh! ' + error);
});
}


Captain Planet
Play Theme!
Pause Song
Superpowers - Change Sizes!
Normal
Grow
Shrink
Superpowers - Invisiblity!
Visible
Invisible
Move Controls
Up
Left
Down
Right
Go Planet!


Babysitter Kata
Note: This post is still a work in progress.
Description
This kata simulates a babysitter working and getting paid for one night. The rules are pretty straight forward.
Initial Thoughts
For this exercise I was given the option to select my own language from a list, I decided to go with Python as it is one of the languages I am most comfortable with. After spending over a year listening to both the PythonBytes and Test & Code podcasts, I had heard enough from Brian Okken to use pytest as the “test” part of my test driven development.
Having never used pytest before, I decided to buy Brian’s book so that I could get a good foundation of how pytest specifically worked. As a side note, I would recommend pytest if you are working on a python project. So I spent a couple of hours storming through that book so that I would have some idea of what I was doing.
After establishing that I was going to use pytest, I planned out the rest of what I was going to use for this project. To make it easier to develop on multiple machines I decided to use virtualenv. This way to use this package on another machine, all I would need to do (after using pip to install virtualenv) is install the packages in the requirements.txt file using pip install -r requirements.txt
and then the package is ready to go.
The other package in requirements.txt file other than pytest is Click. Click is a very powerful package that makes adding a command line interface (CLI) to your python package very easy. Using decorators and functions, defining a CLI is very easy.


Tool released by corelanc0d3r in 2009
Helps find where AD users are logged in
Can also check who's logged into specific machines
But you also need to have admin access on those computers
PVEFindADUser.exe -current


nbcdf(3f) - [M_datapac:CUMULATIVE_DISTRIBUTION] compute the negative binomial cumulative distribution function
Synopsis
Description
Note
Input Arguments
Output Arguments
Examples
Author
Maintainer
License
References
SUBROUTINE NBCDF(X,P,N,Cdf)
REAL(kind=wp),intent(in) :: X REAL(kind=wp),intent(in) :: P INTEGER :: N REAL(kind=wp),intent(out) :: Cdf
NBCDF(3f) computes the cumulative distribution function value at the REAL value X for the negative binomial distribution with REAL Bernoulli probability parameter = P, and integer
The negative binomial distribution used herein has mean = N*(1-P)/P and standard deviation = sqrt(N*(1-P)/(P*P))). this distribution is defined for all non-negative integer X-- X = 0, 1, 2, ... . This distribution has the probability function
f(X) = c(N+X-1,N) * P**N * (1-P)**XWhere c(N+X-1,N) is the combinatorial function equaling the number of combinations of N+X-1 items taken N at a time.
The negative binomial distribution is the distribution of the number of failures before obtaining N successes in an indefinite sequence of Bernoulli (0,1) trials where the probability of success in a precision trial = P.
Even though the input to this cumulative distribution function subroutine for this discrete distribution should (under normal circumstances) be a discrete integer value, the input variable X is REAL in mode.
X has been specified as REAL so as to conform with the datapac convention that all input ****data**** (as opposed to sample size, for example) variables to all datapac subroutines are REAL. This convention is based on the belief that
1. A mixture of modes (floating point versus integer) is inconsistent and an unnecessary complication in a data analysis; and 2. Floating point machine arithmetic (as opposed to integer arithmetic) is the more natural mode for doing data analysis.
X The value at which the cumulative distribution function is to be evaluated. X should be non-negative and integral-valued. P The value of the Bernoulli probability parameter for the negative binomial distribution. P should be between 0.0 (exclusively) and 1.0 (exclusively). N The integer value of the number of successes in Bernoulli
trials parameter. N should be a positive integer.
CDF The cumulative distribution function value for the negative binomial distribution
Sample program:
program demo_nbcdf !@(#) line plotter graph of cumulative distribution function use M_datapac, only : nbcdf, plott, label implicit none real,allocatable :: x(:), y(:) real :: p integer :: i integer :: n call label(nbcdf) x=[(real(i),i=0,100,1)] if(allocated(y))deallocate(y) allocate(y(size(x))) p=0.50 n=size(x) do i=1,size(x) call NBCDF(X(i),P,N,y(i)) enddo call plott(x,y,size(x)) end program demo_nbcdfResults:
The following is a plot of Y(I) (vertically) versus X(I) (horizontally) I-----------I-----------I-----------I-----------I 0.1000000E+03 - X X X 0.9583334E+02 I X X X X 0.9166666E+02 I X X X X 0.8750000E+02 I XX X X 0.8333334E+02 I XXX X 0.7916667E+02 I XXXX 0.7500000E+02 - XXX 0.7083334E+02 I XX 0.6666667E+02 I XX 0.6250000E+02 I X 0.5833334E+02 I X 0.5416667E+02 I X 0.5000000E+02 - X 0.4583334E+02 I X 0.4166667E+02 I X 0.3750000E+02 I X 0.3333334E+02 I X 0.2916667E+02 I X 0.2500000E+02 - X 0.2083334E+02 I X 0.1666667E+02 I X 0.1250000E+02 I X 0.8333336E+01 I X 0.4166672E+01 I X 0.0000000E+00 - X I-----------I-----------I-----------I-----------I -0.1776E-14 0.1250E+00 0.2500E+00 0.3750E+00 0.5000E+00
The original DATAPAC library was written by James Filliben of the Statistical Engineering Division, National Institute of Standards and Technology.
John Urban, 2022.05.31
CC0-1.0
o National Bureau of Standards Applied Mathematics Series 55, 1964, page 945, Formulae 26.5.24 and 26.5.28, and page 929. o Johnson and Kotz, Discrete Distributions, 1969, pages 122-142, especially page 127. o Hastings and Peacock, Statistical Distributions--A Handbook for Students and Practitioners, 1975, pages 92-95. o Feller, an Introduction to Probability Theory and Its Applications, Volume 1, Edition 2, 1957, pages 155-157, 210. o Kendall and Stuart, the Advanced Theory of Statistics, Volume 1, Edition 2, 1963, pages 130-131. o Williamson and Bretherton, Tables of the Negative Binomial Probability Distribution, 1963. o Owen, Handbook of Statistical Tables, 1962, page 304.
| Nemo Release 3.1 | nbcdf (3) | July 22, 2023 |


Toggle print styling using javascript
Toggle
print CSS link is active
screen CSS link is active
print media query is active
screen media query is active


Home
Resume
Blog
About Me
[Your Name Here]'s Resume
Education
University of Delaware
Newark, DE
Majored in Software
GPA(in-major/cumulative): 4.0/4.0
Experience
Your company
Newark, DE
Software Engineer
Developed full feature lifecycles using Javascript.


Topic list
{{ topics.length }}
{{ topic.text }}
Delete topic
Stop streaming topic
Resume streaming topic
The topic has to be written as "database.collection" or "collection", no more than one dot has to be in the string.
Add
Error!
{{errorText}}.
Topic administration prototype for the Smart Enterprise Project.


Zebrahead * * (out of * * * * )
Directed by Anthony Drazan. Cast: Michael Rapaport, N'Bushe Wright, DeShonn Castle, Ron Johnson, Ray Sharkey, Paul Butler, Candy Ann Brown, Helen Shaver, Luke Reilly, Martin Priest, Kevin Corrigan. 1992 - 102 minutes Rated R (for violence, blood, and sexual situations). Capusule Review written June 21, 1999.
The directing debut of Anthony Drazan, "Zebrahead" captured a sizable amount of critical reaction upon its release in 1992, but the film is often overwrought, even if it is well-meaning.  Rapaport and Wright are both outstanding in their respective, three-dimensional roles, but every other character is more or less a distsant caricature or symbol, aside from Nikki's caring, lonely mother (Candy Ann Brown). The ending is especially unconvincing, as it seems to switch to the end credits while still in midstream.
- Copyright 1999 by Dustin Putman Http://hometown.aol.com/FilmFan16/index.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Matthew McConaughey Joins Instagram In A Very Matthew McConaughey Way
The actor rang in his 50th birthday on Monday by announcing his new social media page through videos, songs, and, naturally, some inspiration.
by Jenna Amatulli, HuffPost USMatthew McConaughey is celebrating his 50th birthday with an announcement: He’s officially on Instagram.
On Monday, the actor posted a series of videos on both Twitter and the ’gram to ring in his new handle, which is, aptly, @officiallymcconaughey.
“Born November the 4th 1969, got my dad’s name the very same day. But not until I turned 50, today, did I become @officiallymcconaughey. That’s my Instagram handle. See you there,” says the Texas native in a video he tweeted.
“The Beach Bum” star got candid in his first post on his newly minted page, telling fans in a confessional sort of video: “When people come to my page, I want them to see me. Look, this is my first venture into sharing myself and my views with the world, and I’m a little bit nervous about it, because quite frankly, I know I want to have a monologue. I’m not sure I want to have the dialogue. But I’ve learned that you gotta have the dialogue, too.”
McConaughey waxed poetic a bit, as he’s wont to do ― have you seen those Lincoln ads? ― adding that he also wants to “have some fun” with the platform and hopes his content “makes you think a second” or even “makes your heart swell up a little bit.”
To cover all of his bases, the father of three also sang a little song on his Instagram Story.
“Do I have an Instagram? Well, I’d be a lot cooler if I did. But guess what? It is now a lot cooler because I do,” he says after singing in a velvet chair, as one does.
Oh, boy. We can’t wait to see what sort of antics he gets up to on this platform.


Copy your unique player id:
Download the Everquest Livemap Helper eqlivemap.zip (md5: 564bf9948ca085c64f09652dd2ee9685) This zip includes the binary (.exe) and the source code (AutoIt).
Run the helper app, paste in your unique player id ({{player}}), select your everquest log folder and hit 'GO'. This app simply monitors your Everquest logs for zone and location information and then sends an http request to the server updating your player data
Make sure your logging is enabled in everquest by typing '/log on' in game or edit your eqclient.ini to turn them on permanently
In game change zones or type /who to set the map. Type /loc to update your position on the map.
This page will automatically reveal your map once you have everything configured correctly. Magic!


Shōnen or Shōjo?
What is this?
Lorem Ipsum
What are Shōnen/Shōjo?
Lorem Ipsum
Demo?
Lorem Ipsum
Source code available on
Github


The drip you heard is much closer now. You stop to look around, but there is not much to see. Pretty dim, oh wait, what's that.
A speck of bright light appears off in the distance. Is that a way out, you wonder. You step towards the hopeful brightness, and suddenly something is on you.
You scream out in fear then you realize it's just water. Guess that's where the dripping sound was coming from. Suddenly you realize that your cry has attracted some attention. Footsteps and mumbling from the distance are coming your way.
Oh No! Librarian Viking people! You have to go!
| . . . . . | ||
| Go West | Go East | |
| Go South |


IELTS | PTE | Spoken English
IELTS|PTE| Spoken English
Sankalp consultancy provides incomparable training in IELTS, PTE and spoken English. Our renowned faculty ensures you achieve the best scores possible. Every student is unique and we follow a mentoring model where every student is assigned a personal mentor who steers the student towards success.
Our classes comprise of small batch sizes, ensuring personalized attention. Faculties are available all throughout the course to solve personal doubts and questions. Our well planned curriculum seeks to make the student a master at problem solving. We follow a flexible approach allowing student’s personalized coaching, make up classes, extra classes as well as numerous mock tests throughout the course. Our innovative and new age teaching methodology has allowed us to attain an exceptional track record in the area of study abroad test prep. Batches commence every week and the courses are result oriented. We also have a well-stocked library that consist of Kaplan, Barrons, Cambridge, Princeton publications available.
IELTS
IELTS - International English Language Testing System is a globally recognized, standarized English Proficiency Test that assesses English Language Skills in the areas of Listening, Reading, Writing and Speaking. This test is recognized by over 9000 organizations worldwide. IELTS consists of two types of modules - Academic and General Training. Academic Module is required to be given by test takers who plan to study at an undergraduate or postgraduate level. While, General Training Module is generally a prerequisite for candidates who either want to pursue vocational studies or plan to immigrate.
IELTS Test format is divided into 6 sections namely-
Test Format:
Listening
40 Questions to be answered in 40 Minutes
Reading Academic Module
3 passages (40 Questions) to be answered in 60 Minutes
Reading General Module
3 sections (40 Questions) to be answered in 60 Minutes
Writing Academic Module
2 tasks (Diagram Prompt/Argument Prompt) to be answered in 60 minutes
Writing General Module
2 tasks (Letter Prompt/Essay Prompt) in 60 minutes.
Speaking
3 Parts in 11 to 15 minutes The Total duration of the entire Test Format is 2 Hours 45 Minutes.
Sections:
Listening :
It has 4 sections and 40 questions in all. It lasts for 40 minutes including 10 minutes transfer time for the answers to the main answer sheet.
Reading :
Reading has 3 passages, 40 questions in all. Candidates are given only 1 hour to complete reading.
Writing Academic Module :
It has 2 writing tasks. Task 1 is primarily Report writing (explaining diagrams and charts). Essay on task 1 must not be less than 150 words. Students are advised to spend 20 minutes on this task. Task 2 is Argumentative essay. Essay on task 2 must not be less than 250 words. Students are advised to spend 40 minutes on the same. In all time allotted for writing is 1 hour.
Writing General Training Module :
It also has 2 writing tasks. Task1 presents a Letter Prompt (formal or informal). Students must write at least 150 words for the same. Task 2 is same as that of Academic Module.
Speaking :
Speaking has 3 parts and lasts for 11-14 minutes. It is done on one-to-one basis with the student. This is usually done on another day.
Part1:
Examiner asks general questions to the student, which relates to his/her work, studies, hobbies etc. This part lasts between 4 and 5 minutes.
Part2:
The candidate is given a topic to speak, which is printed on a task card. Students have to speak for 1 minute at least and are given one minute to think and write down some points. This part lasts between 3 and 4 minutes.
Part3 :
It's a two way discussion with the examiner (questions mostly related to part 2 topic will be asked). The discussion lasts between 4 and 5 minutes.
PTE (Pearson Test of English)
Structure of PTE
| Parts | Format | Duration |
|---|---|---|
| SPEAKING & WRITING | Personal Introduction
Read aloud Repeat sentence Describe image Re-tell lecture Answer short question Summarize written text Essay (20mins) |
77 – 93 minutes |
| READING | Fill in the blanks
Multiple choice questions Re-order paragraphs Fill in the blanks Multiple choice questions |
32 – 41 minutes |
| LISTENING | Summarize spoken text
Multiple choice questions Fill the blanks Highlight the correct summary Multiple choice questions Select missing word Highlight incorrect words Write from dictation |
45 – 57 minutes |
Spoken English
Depending upon English Language proficiency of students we offers a range of English Communication program as per your level and needs:
Level-1 Sankalp-Beginners:
Focuses on basic grammar, Basic English speaking, and vocabulary.
Level-2 Sankalp-Advance:
Helps bulid fluency with selected vocabulary and speak in different situation.
Level-3 Sankalp-Experts:
Enriches language through voice and accent and voice modulation training.
Following are the topics that are covered in our course
Basic Grammar
Sentence Construction
Accent Correction
Personal skill Enhancement
Free Expression
Building positive attitude
Building confidence
Interpersonal skills
Time management
Stress management
Grooming
Art of communication
Body language
Negotiation skills
Objection Handling
CV Drafting
Power Dressing
Etiquettes
Stress Management
Answering Tough Questions
Career Counselling
Career Counseling is a process that will help you to know and understand yourself and the world of work in order to make career, educational and life decisions.
Admission & Visa Guidance
With an array of academic choices amongst destinations, universities, colleges and courses offered worldwide, making the right decision can be difficult.


| Source File | test.sch |
| BoM Date | Date |
| Schematic Version | v1.1 |
| Schematic Date | 2020-11-05 |
| PCB Variant | default |
| KiCad Version | Eeschema 5.1.9+dfsg1-1~bpo10+1 |
| Component Groups | 4 |
| Component Count (per PCB) | 6 |
| Fitted Components (per PCB) | 6 |
| Number of PCBs | 1 |
| Total Component Count (for 1 PCBs) | 6 |
KiCad Fields (default)
Generated Fields
User Fields
Empty Fields
| Description | Part | References | Value | Footprint | Quantity Per PCB | Datasheet | mpn | variant | |
|---|---|---|---|---|---|---|---|---|---|
| 1 | Unpolarized capacitor | C | C1 C2 | 100nF | C_1206_3216Metric | 2 | ~ | CL10B104JB8NNND | |
| 2 | Resistor | R | R1 R2 | R | R_0805_2012Metric | 2 | ~ | 1 | var1 var2 |
| 3 | Full Speed USB to Basic UART, QFN-16 | FT230XQ | U2 | FT230XQ | QFN-16-1EP_4x4mm_P0.65mm_EP2.1x2.1mm | 1 | https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT230X.pdf | FT230XQ-R | |
| 4 | 300mA Low Dropout Voltage Regulator, Fixed Output 3.3V, SOT-23-5 | TLV70233_SOT23-5 | U1 | TLV70233_SOT23-5 | SOT-23-5 | 1 | http://www.ti.com/lit/ds/symlink/tlv702.pdf | TLV70233PDBVT |


assay.properties.nsim.Rd
The external study data for mean window and MDRI is available here from Duong et al. 2015: https://doi.org/10.1371/journal.pone.0114947.s001
assay.properties.nsim( n_sims, phi.func, bigT, tau, ext_FRR = FALSE, ext_df = NULL, max_FRR = NULL, last_point = FALSE )
| n_sims | Number of simulations |
|---|---|
| phi.func | A test-recent positive function of t |
| bigT | The time cutoff value designating true recent versus false recent |
| tau | The maximum duration of infection where a subject could have a false-positive for recent infection |
| ext_FRR | Whether or not to get FRR from the Duong et al. 2015
study or to calculate it from a simpler, separate study, passed in |
| ext_df | A dataset with column "duration" and column for binary "recent" indicator |
| max_FRR | The maximum duration allowed |
| last_point | Integrate the mean window period to the last observed duration in the dataset, rather than tau |
A list of estimated mean window period \(\mu\) and its variance, estimated MDRI \(\Omega_{T^*}\) and its variance, and estimated FRR \(\beta_{T^*}\) and its variance.
set.seed(0) assay.properties.nsim(n_sims=1, phi.func=function(t) 1 - pgamma(t, 1, 1.5), bigT=2, tau=12)#> Error in geese(gap ~ samp + samp.5 + samp.5 * samp, id = id.key, data = df, family = poisson(link = "log"), corstr = "exchangeable"): could not find function "geese"


Anthony scores 10 points in Blazers debut
Forward Carmelo Anthony officially joined the Trail Blazers on Tuesday, and he scored 10 points in Portland’s 115-104 road loss to the New Orleans Pelicans.
The Blazers were without star guard Damian Lillard, who was sidelined due to back spasms.
“It felt great to be back in the flow of the game, be back on the court, be back to where I think I belong at,” Anthony said postgame, according to ESPN. “Just being back out there with the guys again. I think most of all the routine — team bus, team lunch, being around the guys in the locker room — just the routine I’ve been used to for 17 years now ... so getting back into that. As far as the game goes, it felt good to be back out there.”
The Trail Blazers activated Anthony prior to the contest. Coach Terry Stotts told reporters Anthony would start at power forward and play about 20 minutes, and the 10-time All-Star did start and wound up playing 23:37. Anthony hit 4 of 14 shots, including 2 of 3 from 3-point range.
Lillard was scratched due to the back soreness he has dealt with for close to a week. He has hit just 10 of 46 shots over his past three games.
It wasn’t immediately known whether Lillard would miss more than one game. He is averaging 28.6 points and 7.1 assists in 14 games.
According to reports, Anthony’s one-year, non-guaranteed contract is worth up to $2.15 million.
The 35-year-old veteran had not played a game in the NBA since Nov. 8, 2018 with the Houston Rockets. Houston traded him to Chicago on Jan. 22, and the Bulls waived him on Feb. 1.
Before Tuesday, Anthony held career NBA averages of 24.0 points, 6.5 rebounds, 3.0 assists and 1.02 steals in 1,064 games (1,056 starts) over 16 seasons with Denver, New York, Oklahoma City and Houston.
The Blazers granted Anthony’s request to return to the league in uniform number No. 00.
—Field Level Media


Post a Job
Peeljobs is offering unlimited job posting and for the unlimited time period
Your post will be on live within one hour and you will get a notification mail if any job seeker applied for
your job
Connect with social Networking sites to post jobs on your timeline


|
|
Flagger with own dictionary, and accepting values of (integer) type T. More...
#include <Flags.h>
Public Types | |
| typedef F | fbase_t |
| typedef fbase_t::value_t | value_t |
| typedef fbase_t::dict_t | dict_t |
Public Member Functions | |
| virtual const dict_t & | getDict () const |
| virtual dict_t & | getDict () |
| Flags2 () | |
| Flags2 (std::initializer_list< typename dict_t::entry_t > list) | |
| Constructor for relatively short dictionaries. More... | |
| Flags2 (const Flags2< F > &flags) | |
| template<class T > | |
| Flags2< F > & | operator= (const T &v) |
Protected Attributes | |
| dict_t | dict |
Flagger with own dictionary, and accepting values of (integer) type T.
Designed for local, instantaneous use. Should several flaggers use the same dictionary, use Flagger2<F> instead.
| F | – SingleFlagger<T> or MultiFlagger<T> |
|
inline |
Constructor for relatively short dictionaries.


Axis User's Guide
Beta 1 Version
Table of Contents
Introduction
Welcome to Axis, the third generation of Apache SOAP! This is the beta 1 version. Please note that Axis is a work in progress, and although
the basic functionality is there, there are still some unfinished areas
and rough edges. That said, we're very psyched about the package so far
and would love to get your take on how we can make it better.
What is SOAP?
SOAP is an XML-based communitcation protocol and encoding format
for inter-application communication. Originally conceived by Microsoft
and Userland software, it has evolved through several generations and the
current spec, SOAP 1.1, is fast growing
in popularity and usage. The W3C's XML Protocol working group is in the
process of turning SOAP into a true open standard, and as of this writing
has released a working draft of SOAP 1.2, which cleans up some of the more
confusing areas of the 1.1 spec.
SOAP is widely viewed as the backbone to a new generation of cross-platform
cross-language distributed computing applications, termed Web Services.
What is Axis?
Apache SOAP began at IBM as "SOAP4J" and then became Apache SOAP version
2. The committers on the v2 project began some conversations in late 2000
about making the engine much more flexible, configurable, and able to handle
both SOAP and the upcoming XML Protocol specification from the W3C.
After a little while, it became clear that a ground-up rearchitecture
was the way to go. Several of the v2 committers proposed very similar designs,
all based around configurable "chains" of message "handlers" which would
implement small bits of functionality in a very flexible and composable
manner. Axis is the result of months of continued discussion and coding
effort in this direction. Some of the key Axis features include the following:
-
Speed. Axis uses SAX (event-based) parsing to acheive significantly
greater speed than earlier versions of Apache SOAP.
-
Flexibility. The Axis architecture gives the developer complete
freedom to insert extensions into the engine for custom header processing,
system management, or anything else you can imagine.
-
Stability. Axis defines a set of
published
interfaces which change relatively slowly compared to the rest of Axis.
-
Component-oriented deployment. You can easily define reusable networks
of Handlers to implement common patterns of processing for your applications,
or to distribute to partners.
-
Transport framework. We have a clean and simple abstraction for
designing transports (i.e. senders and listeners for SOAP over various
protocols such as SMTP, FTP, message-oriented middleware, etc), and the
core of the engine is completely transport-independent.
We hope you enjoy using Axis. Please note that this is an open-source effort
- if you feel the code could use some new features or fixes, please get
involved and lend a hand! The Axis developer community welcomes your participation.
Let us know what you think!
Please send feedback about the package to<EMAIL_ADDRESS>Also, Axis is regsitered in bugzilla,
the Apache bug tracking and feature-request database.
What's in this release?
This release includes the following features:
- SOAP 1.1 compliant engine
- Flexible configuration / deployment system
- Support for "drop-in" deployment of SOAP services (JWS)
- Support for all basic types, and a type mapping system for defining new
serializers/deserializers
- Automatic serialization/deserialization of Java Beans
- Automatic two-way conversions between Java "List" collections and SOAP
Arrays
- Providers for RPC and message based SOAP services
- Automatic WSDL generation from deployed services
- WSDL2Java tool for building Java proxies and skeletons from WSDL documents
- Java2WSDL tool for building WSDL from Java classes.
- Preliminary security extensions, which can integrate with Servlet 2.2 security/roles
- Preliminary support for the SOAP with Attachments specification
- An EJB provider for accessing EJB's as Web Services
- HTTP servlet-based transport
- Standalone version of the server (with HTTP support)
- Examples, including a client and server for the soapbuilders community
interoperability tests
What's missing?
TBD
Installing Axis and Using this Guide
See the Axis Installation Guide
for instructions on installing Axis as a web application on your J2EE server.
Before running the examples in this guide, you'll need to make sure
that your CLASSPATH includes (note: if you build axis from a CVS checkout, these will be in xml-axis/java/build/lib instead of xml-axis-beta1/lib):
- xml-axis-beta1/lib/axis.jar
- xml-axis-beta1/lib/jaxrpc.jar
- xml-axis-beta1/lib/clutil.jar
- xml-axis-beta1/lib/commons-logging.jar
- xml-axis-beta1/lib/tt-bytecode.jar
- xml-axis-beta1/lib/wsdl4j.jar
- xml-axis-beta1/ # for the sample code
- A JAXP-1.1 compliant XML parser such as xerces or crimson
Consuming Web Services with Axis
Basics - Getting Started
Let's take a look at an example Web Service client that will call the echoString
method on the public Axis server at Apache.
1 import org.apache.axis.client.Call;
2 import org.apache.axis.client.Service;
3 import javax.xml.rpc.namespace.QName;
4
5 public class TestClient {
6 public static void main(String [] args) {
7 try {
8 String endpoint =
9 "http://nagoya.apache.org:5049/axis/servlet/AxisServlet";
10
11 Service service = new Service();
12 Call call = (Call) service.createCall();
13
14 call.setTargetEndpointAddress( new java.net.URL(endpoint) );
15 call.setOperationName( new QName("http://soapinterop.org/", "echoString") );
16
17 String ret = (String) call.invoke( new Object[] { "Hello!" } );
18
19 System.out.println("Sent 'Hello!', got '" + ret + "'");
20 } catch (Exception e) {
21 System.err.println(e.toString());
22 }
23 }
24 }
(You'll find this file in samples/userguide/example1/TestClient.java)
Assuming you have a network connection active, this program can be run
as follows:
% java samples.userguide.example1.TestClient
Sent 'Hello!', got 'Hello!'
%
So what's happening here? On lines 11 and 12 we create new Service and
Call objects. These are the standard JAX-RPC objects that are used to store
metadata about the service to invoke. On line 14, we set up our endpoint
URL - this is the destination for our SOAP message. On line 15 we define
the operation (method) name of the Web Service. And on line 17 we actually invoke
the desired service, passing in an array of parameters - in this case just
one String.
You can see what happens to the arguments by looking at the SOAP request
that goes out on the wire (look at the colored sections, and notice they
match the values in the call above):
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Body>
<ns1:echoString xmlns:ns1="http://soapinterop.org/">
<arg0 xsi:type="xsd:string">Hello!</arg0>
</ns1:echoString>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
The String argument is automatically serialized into XML, and the server
responds with an identical String, which we deserialize and print.
Note: to actually watch the XML flowing back and forth between a
SOAP client and server, you can use the included tcpmon tool. See the appendix
for an overview.
Naming Parameters
In the above example, the parameters are in the order in which we sent
them, but since we only passed the objects themselves, Axis automatically
named the XML-encoded arguments in the SOAP message "arg0", "arg1", etc.
If you want to change this, it's easy! Before calling invoke()
you need to call addParameter for each parameter, like so:
call.addParameter("testParam",
org.apache.axis.encoding.XMLType.XSD_STRING,
javax.xml.rpc.ParameterMode.PARAM_MODE_IN);
This will assign the name testParam to the 1st (and only) parameter
on the invoke call. This will also define the type of the parameter (org.apache.axis.encoding.XMLType.XSD_STRING)
and whether it is an input, output or inout parameter - in this case its
an input parameter. Now when you run the program you'll get a message that
looks like this:
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Body>
<ns1:echoString xmlns:ns1="http://soapinterop.org/">
<testParam xsi:type="xsd:string">Hello!</testParam>
</ns1:echoString>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Note that the param is now named "testParam" as expected.
Interoperating with "untyped" servers
In the above examples, we've been casting the return type of invoke(),
which is Object, to the appropriate "real" type - for instance, we know
that the echoString method returns a String, so we expect to get one back
from client.invoke(). Let's take a moment and investigate how this happens,
which sheds light on a potential problem (to which, of course, we have
a solution - so don't fret :)).
Here's what a typical response might look like to the echoString method:
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Body>
<ns1:echoStringResponse xmlns:ns1="http://soapinterop.org/">
<result xsi:type="xsd:string">Hello!</result>
</ns1:echoStringResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Take a look at the section which we've highlighted in red
- that attribute is a schema type declaration, which Axis uses to figure
out that the contents of that element are, in this case, deserializable into a
Java String object. Many toolkits put this kind of explicit typing information
in the XML to make the message "self-describing". On the other hand, some toolkits
return responses that look like this:
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Body>
<ns1:echoStringResponse xmlns:ns1="http://soapinterop.org/">
<result>Hello, I'm a string!</result>
</ns1:echoStringResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
There's no type in the message, so how do we know what Java object we should
deserialize the <result> element into? The answer is metadata
- data about data. In this case, we need a description of the service
that tells us what to expect as the return type. Here's how to do it on
the client side in Axis:
call.setReturnType( org.apache.axis.encoding.XMLType.XSD_STRING );
This method will tell the Axis client that if the return element is not
typed then it should act as if the return value has an xsi:type attribute
set to the predefined SOAP String type. (You can see an example of this
in action in the interop echo-test client - samples/echo/TestClient.java.)
OK - so now you know the basics of accessing SOAP services as a client.
But how do you publish your own services?
Publishing Web Services with Axis
Let's say we have a simple class like the following:
public class Calculator {
public int add(int i1, int i2)
{
return i1 + i2;
}
public int subtract(int i1, int i2)
{
return i1 - i2;
}
}
(You'll find this very class in samples/userguide/example2/Calculator.java.)
How do we go about making this class available via SOAP? There are a
couple of answers to that question, but we'll start with the easiest way
Axis provides to do this, which takes almost no effort at all!
JWS (Java Web Service) Files - Instant Deployment
OK, here's step 1 : copy the above .java file into your webapp directory,
and rename it "Calculator.jws". So you might do something like this:
% copy Calculator.java <your-webapp-root>/axis/Calculator.jws
Now for step 2... hm, wait a minute. You're done! You should now be able
to access the service at the following URL (assuming your Axis web application
is on port 8080):
http://localhost:8080/axis/Calculator.jws
Axis automatically locates the file, compiles the class, and converts
SOAP calls correctly into Java invocations of your service class. Try it
out - there's a calculator client in samples/userguide/example2/CalcClient.java,
which you can use like this:
% java samples.userguide.example2.CalcClient -p8080 add 2 5
Got result : 7
% java samples.userguide.example2.CalcClient -p8080 subtract 10 9
Got result : 1
%
(note that you may need to replace the "-p8080" with whatever port your
J2EE server is running on)
Custom Deployment - Introducing WSDD
JWS files are great quick ways to get your classes out there as Web Services,
but they're not always the best choice. For one thing, you need the source
code - there might be times when you want to expose a pre-existing class
on your system without source. Also, the amount of configuration you can
do as to how the service gets accessed is pretty limited - you can't specify
custom type mappings, or control which Handlers get invoked when people
are using your service.
Deploying via descriptors
To really use the flexibility available to you in Axis, you should get
familiar with the Axis Web Service Deployment Descriptor (WSDD)
format. A deployment descriptor contains a bunch of things you want to
"deploy" into Axis - i.e. make available to the Axis engine. The most common
thing to deploy is a Web Service, so let's start by taking a look at a
deployment descriptor for a basic service (this file is samples/userguide/example3/deploy.wsdd):
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="MyService" provider="java:RPC">
<parameter name="className" value="samples.userguide.example3.MyService"/>
<parameter name="allowedMethods" value="*"/>
</service>
</deployment>
Pretty simple, really - the outermost element tells the engine that this
is a WSDD deployment, and defines the "java" namespace. Then the service
element actually defines the service for us. A service is a targeted chain (see the Architecture Guide), which means it may have
any/all of: a request Handler, a pivot Handler (which for a service is
called a "provider"), and a response Handler. In this case, our provider
is "java:RPC", which is predefined to indicate a Java RPC service.
We need to tell the RPCDispatcher that it should instantiate and call
the correct class (e.g. samples.userguide.example3.MyService), and we do
so by including a <parameter> tag, giving the service one parameter
to configure the class name, and another to tell the engine that any public
method on that class may be called via SOAP (that's what the "*" means;
we could also have restricted the SOAP-accessible methods by using a space
or comma separated list of available method names).
Using the AdminClient
Once we have this file, we need to send it to an Axis server in order to
actually deploy the described service. We do this with the AdminClient,
or the "org.apache.axis.client.AdminClient" class. An invocation of the
AdminClient looks like this:
% java org.apache.axis.client.AdminClient deploy.wsdd
<Admin>Done processing</Admin>
This command has now made our service accessible via SOAP. Check it out
by running the Client class - it should look like this:
% java samples.userguide.example3.Client "test me!"
You typed : test me!
%
If you want to prove to yourself that the deployment really worked, try
undeploying the service and calling it again. There's an "undeploy.wsdd"
file in the example3/ directory which you can use just as you did the deploy.wsdd
file above. Run the AdminClient on that file, then try the service
Client again and see what happens.
You can also use the AdminClient to get a listing of all the deployed
components in the server:
% java org.apache.axis.client.AdminClient list
<big XML document returned here>
In there you'll see services, handlers, transports, etc. Note that this
listing is an exact copy of the server's "server-config.wsdd" file, which
we'll talk about in more detail a little later.
More deployment - Handlers and Chains
Now let's start to explore some of the more powerful features of the Axis
engine. Let's say you want to track how many times your service has been
called. We've included a sample handler in the samples/log directory to
do just this. To use a handler class like this, you first need to deploy
the Handler itself, and then use the name that you give it in deploying
a service. Here's a sample deploy.wsdd file (this is example 4 in samples/userguide):
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<!-- define the logging handler configuration -->
<handler name="track" type="java:samples.userguide.example4.LogHandler">
<parameter name="filename" value="MyService.log"/>
</handler>
<!-- define the service, using the log handler we just defined -->
<service name="LogTestService" provider="java:RPC">
<requestFlow>
<handler type="track"/>
</requestFlow>
<parameter name="className" value="samples.userguide.example4.Service"/>
<parameter name="allowedMethods" value="*"/>
</service>
</deployment>
The first section defines a Handler called "track" that is implemented
by the class samples.userguide.example4.LogHandler. We give this Handler
an option to let it know which file to write its messages into.
Then we define a service, LogTestService, which is an RPC service just
like we saw above in our first example. The difference is the <requestFlow>
element inside the <service> - this indicates a set of Handlers that
should be invoked when the service is invoked, before the provider. By
inserting a reference to "track", we ensure that the message will be logged
each time this service is invoked.
Remote Administration
Note that by default, the Axis server is configured to only accept administration
requests from the machine on which it resides - if you wish to enable remote
administration, you must set the "enableRemoteAdmin" property of the AdminService
to true. To do this, find the "server-config.wsdd" file in your
webapp's WEB-INF directory. In it, you'll see a deployment for the AdminService.
Add an option as follows:
<service name="AdminService" provider="java:MSG">
<parameter name="className" value="org.apache.axis.util.Admin"/>
<parameter name="allowedMethods" value="*"/>
<parameter name="enableRemoteAdmin" value="true"/>
</service>
WARNING: enabling remote administration may give unauthorized parties
access to your machine. If you do this, please make sure to add security
to your configuration!
XML <-> Java Data Mapping in Axis
Encoding Your Beans - the BeanSerializer
Axis includes the ability to serialize/deserialize, without writing any
code, arbitrary Java classes which follow the standard JavaBean pattern
of get/set accessors. All you need to do is tell Axis which Java classes
map to which XML Schema types. Configuring a bean mapping looks like this:
<beanMapping qname="ns:local" xmlns:ns="someNamespace"
languageSpecificType="java:my.java.thingy"/>
The <beanMapping> tag maps a Java class (presumably a bean) to an XML
QName. You'll note that it has two important attributes, qname and
languageSpecificType.
So in this case, we'd be mapping the "my.java.thingy" class to the XML
QName [someNamespace]:[local].
Let's take a look at how this works in practice. Go look at samples/userguide/example5/BeanService.java. The key
thing to notice is that the argument to the service method is an Order
object. Since Order is not a basic type which Axis understands by default,
trying to run this service without a type mapping will result in a fault
(if you want to try this for yourself, you can use the bad-deploy.wsdd
file in the example5 directory). But if we put a beanMapping into our deployment,
all will be well. Here's how to run this example (from the example5 directory):
% java org.apache.axis.client.AdminClient -llocal:///AdminService deploy.wsdd
<Admin>Done processing</Admin>
% java samples.userguide.example5.Client -llocal://
Hi, Glen Daniels!
You seem to have ordered the following:
1 of item : mp3jukebox
4 of item : 1600mahBattery
If this had been a real order processing system, we'd probably have charged you about now.
%
When Beans Are Not Enough - Custom Serialization
Just as JWS deployment is sometimes not flexible enough to meet all needs,
the default bean serialization model isn't robust enough to handle every
case either. At times there will be non-bean Java classes (especially in
the case of pre-existing assets) which you need to map to/from XML, and
there also may be some custom XML schema types which you want to map into
Java in particular ways. Axis gives you the ability to write custom serializers/deserializers,
and some tools to help make your life easier when you do so.
TBD - this section will be expanded in a future
version! For now, take a look at the ArraySerializer, the BeanSerializer
(both in org.apache.axis.encoding), and the DataSer example (in samples/encoding)
to see how custom serializers work.
Deploying custom mappings - the <typeMapping> tag
Now that you've built your serializers and deserializers, you need to tell
Axis which types they should be used for. You do this with a typeMapping
tag in WSDD, which looks like this:
<typeMapping qname="ns:local" xmlns:ns="someNamespace"
languageSpecificType="java:my.java.thingy"
serializer="my.java.Serializer"
deserializer="my.java.DeserializerFactory"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
This looks a lot like the <beanMapping> tag we saw earlier, but there
are three extra attributes. One, serializer, is the Java class name
of the Serializer class which should be used to write the specified Java
class (i.e. my.java.thingy) into XML. Two, deserializer, is
the class name of a Deserializer factory that generates Deserializers
which can be used to unmarshall XML into the correct Java class. Finally, the encoding style, which is SOAP encoding.
(The <beanMapping> tag is really just shorthand for a <typeMapping>
tag with serializer="org.apache.axis.encoding.BeanSerializer", deserializer="org.apache.axis.encoding.BeanSerializer$BeanDeserFactory", and encodingStyle="http://schemas.xmlsoap.org/soap/encoding/",
but clearly it can save a lot of typing!)
Using WSDL with Axis
The Web Service Description Language
is a specification authored by IBM and Microsoft, and supported by many
other organizations. WSDL serves to describe Web Services in a structured
way. A WSDL description of a service tells us, in a machine-understandable
way, the interface to the service, the data types it uses, and where the
service is located. Please see the spec (follow the link in the first sentence)
for details about WSDL's format and options.
Axis supports WSDL in three ways:
-
When you deploy a service in Axis, users may then access your service's
URL with a standard web browser and by appending "?WSDL" to the end of
the URL, they will obtain an automatically-generated WSDL document which
describes your service.
-
We provide a "WSDL2Java" tool which will build Java proxies and skeletons
for services with WSDL descriptions.
-
We provide a "Java2WSDL" tool which will build WSDL from Java classes.
?WSDL: Obtaining
WSDL for deployed services
When you make a service available using Axis, there is typically a unique
URL associated with that service. For JWS files, that URL is simply the
path to the JWS file itself. For non-JWS services, this is usually the
URL "http://<host>/axis/services/<service-name>".
If you access the service URL in a browser, you'll see a message indicating
that the endpoint is an Axis service, and that you should usually access
it using SOAP. However, if you tack on "?wsdl" to the end of the URL, Axis
will automatically generate a service description for the deployed service,
and return it as XML in your browser (try it!). The resulting description
may be saved or used as input to proxy-generation, described next. You
can give the WSDL-generation URL to your online partners, and they'll be
able to use it to access your service with toolkits like .NET, SOAP::Lite,
or any other software which supports using WSDL.
You can also generate WSDL files from existing Java classes (see Java2WSDL:
Building WSDL from Java ).
WSDL2Java:
Building stubs, skeletons, and data types from WSDL
Client-side bindings
You'll find the AXIS WSDL -> Java tool in "org.apache.axis.wsdl.WSDL2Java".
The basic invocation form looks like this:
% java org.apache.axis.wsdl.WSDL2Java
(WSDL-file-URL)
This will generate only those bindings necessary for the client.
AXIS follows the JAX-RPC specification when generating Java client bindings
from WSDL. For this discussion, assume we executed the following:
% cd samples/addr
% java org.apache.axis.wsdl.WSDL2Java
AddressBook.wsdl
The generated files will reside in the directory "AddressFetcher2".
They are put here because that is the target namespace from the WSDL and namespaces map to Java packages.
Namespaces will be discussed in detail later.
| WSDL clause |
Java class(es) generated |
| For each entry in the type section |
A java class |
|
A holder if this type is used as an inout/out parameter |
| For each portType |
A java interface |
| For each binding |
A stub class |
| For each service |
A service interface |
|
A service implementation (the locator) |
Types
The Java class generated from a WSDL type will be named from the WSDL type.
This class will typically, though not always, be a bean. For example,
given the WSDL (the WSDL used throughout the WSDL2Java discussion is from
the Address Book sample):
<xsd:complexType
name="phone">
<xsd:all>
<xsd:element name="areaCode" type="xsd:int"/>
<xsd:element name="exchange" type="xsd:string"/>
<xsd:element name="number" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
WSDL2Java will generate:
public class Phone implements java.io.Serializable {
public Phone() {...}
public int getAreaCode() {...}
public void setAreaCode(int areaCode) {...}
public java.lang.String getExchange() {...}
public void setExchange(java.lang.String exchange) {...}
public java.lang.String getNumber() {...}
public void setNumber(java.lang.String number) {...}
}
Holders
This type may be used as an inout or out parameter. Java does not
have the concept of inout/out parameters. In order to achieve this
behavior, JAX-RPC specifies the use of holder classes. A holder class
is simply a class that contains an instance of its type. For example,
the holder for the Phone class would be:
public final class PhoneHolder implements
javax.xml.rpc.holders.Holder {
public Phone value;
public PhoneHolder()
{
}
public PhoneHolder(Phone value) {
this.value = value;
}
}
A holder class is only generated for a type if that type is used as
an inout or out parameter.
The holder classes for the primitive types can be found in javax.xml.rpc.holders.
PortTypes
The Service Definition Interface (SDI) is the interface that's derived
from a WSDL's portType. This is the interface you use to access the
operations on the service. For example, given the WSDL:
<message name="empty">
<message name="AddEntryRequest">
<part name="name" type="xsd:string"/>
<part name="address" type="typens:address"/>
</message>
<portType name="AddressBook">
<operation name="addEntry">
<input message="tns:AddEntryRequest"/>
<output message="tns:empty"/>
</operation>
</portType>
WSDL2Java will generate:
public interface AddressBook extends
java.rmi.Remote {
public void addEntry(String
name, Address address) throws java.rmi.RemoteException;
}
A note about the name of the SDI. The name of the SDI is typically the name of the portType. However, to construct the SDI, WSDL2Java needs information from both the portType and the binding. (This is unfortunate and is a topic of discussion for WSDL version 2.)
JAX-RPC says (section 4.3.3): "The name of the Java interface is mapped
from the name attribute of the wsdl:portType element. ... If the mapping to
a service definition interface uses elements of the wsdl:binding ..., then
the name of the service definition interface is mapped from the name of the
wsdel:binding element."
Note the name of the spec. It contains the string "RPC". So this spec,
and WSDL2Java, assumes that the interface generated from the portType is an
RPC interface. If information from the binding tells us otherwise (in
other words, we use elements of the wsdl:binding), then the name of the
interface is derived instead from the binding.
Why? We could have one portType - pt - and two bindings - bRPC and
bDoc. Since document/literal changes what the interface looks like, we cannot use a single interface for both of these bindings, so we end up with 2 interfaces - one named pt and another named bDoc - and two stubs - bRPCStub (which implements pt) and bDocStub (which implements bDoc).
Ugly, isn't it? But you can see why it's necessary. Since document/literal changes what the interface looks like, and we could have more than one binding referring to a single portType, we have to create more than one interface, and each interface must have a unique name.
Bindings
A Stub class implements the SDI. Its name is the binding name with
the suffix "Stub". It contains the code which turns the method invocations
into SOAP calls using the Axis Service and Call objects. It stands
in as a proxy (another term for the same idea) for the remote service,
letting you call it exactly as if it were a local object. In other words,
you don't need to deal with the endpoint URL, namespace, or parameter arrays
which are involved in dynamic invocation via the Service and Call objects.
The stub hides all that work for you.
Given the following WSDL snippet:
<binding name="AddressBookSOAPBinding"
type="tns:AddressBook">
...
</binding>
WSDL2Java will generate:
public class AddressBookSOAPBindingStub
extends org.apache.axis.client.Stub implements AddressBook {
public AddressBookSOAPBindingStub()
throws org.apache.axis.AxisFault {...}
public AddressBookSOAPBindingStub(URL
endpointURL, javax.xml.rpc.Service service) throws org.apache.axis.AxisFault
{..}
public AddressBookSOAPBindingStub(javax.xml.rpc.Service
service) throws org.apache.axis.AxisFault {...}
public void addEntry(String
name, Address address) throws RemoteException{...}
}
Services
Normally, a client program would not instantiate a stub directly.
It would instead instantiate a service locator and call a get method which
returns a stub. This locator is derived from the service clause in
the WSDL. WSDL2Java generates two objects from a service clause.
For example, given the WSDL:
<service name="AddressBookService">
<port name="AddressBook" binding="tns:AddressBookSOAPBinding">
<soap:address location="http://localhost:8080/axis/services/AddressBook"/>
</port>
</service>
WSDL2Java will generate the service interface:
public interface AddressBookService
extends javax.xml.rpc.Service {
public String getAddressBookAddress();
public AddressBook
getAddressBook() throws javax.xml.rpc.ServiceException;
public AddressBook
getAddressBook(URL portAddress) throws javax.xml.rpc.ServiceException;
}
WSDL2Java will also generate the locator which implements this interface:
public class AddressBookServiceLocator
extends org.apache.axis.client.Service implements AddressBookService {
...
}
The service interface defines a get method for each port listed in the
service element of the WSDL. The locator is the implementation of this
service interface. It implements these get methods. It serves as
a locator for obtaining Stub instances. The Service class will by default
make a Stub which points to the endpoint URL described in the WSDL file,
but you may also specify a different URL when you ask for the PortType.
A typical usage of the stub classes would be as follows:
public class Tester
{
public static void main(String
[] args) throws Exception {
// Make a service
AddressBookService
service = new AddressBookServiceLocator();
// Now use the service
to get a stub which implements the SDI.
AddressBook port
= service.getAddressBook();
// Make the actual call
Address address = new Address(...);
port.addEntry("Russell Butek", address);
}
}
Server-side bindings
Just as a stub is the client side of a Web Service represented in Java,
a skeleton is a Java framework for the server side. To make
skeleton classes, you just specify the "--skeleton" option to WSDL2Java.
For instance, using the AddressBook.wsdl as we had above:
% java org.apache.axis.wsdl.WSDL2Java
--skeleton AddressBook.wsdl
You will see that WSDL2Java generates all the classes that were generated
before for the client, but it generates a few new files:
| WSDL clause |
Java class(es) generated |
| For each binding |
A skeleton class |
|
An implementation template class |
| For each service |
deploy.wsdd |
|
undeploy.wsdd |
Bindings
The skeleton class is the class that sits between the AXIS engine and the
actual service implementation. Its name is the binding name with
suffix "Skeleton". For example, for the AddressBook binding, WSDL2Java
will generate:
public class AddressBookSOAPBindingSkeleton
implements AddressBook,
org.apache.axis.wsdl.Skeleton {
private AddressBook impl;
public AddressBookSOAPBindingSkeleton() {
this.impl = new AddressBookSOAPBindingImpl();
}
public AddressBookSOAPBindingSkeleton(AddressBook impl) {
this.impl = impl;
}
public void addEntry(java.lang.String
name, Address address) throws java.rmi.RemoteException
{
impl.addEntry(name, address);
}
}
(The real skeleton is actually much richer. For brevity I'm just
showing you the basic skeleton.)
The skeleton contains an implementation of the AddressBook service.
This implementation is either passed into the skeleton on construction,
or an instance of the generated implementation is created. When the
AXIS engine calls the skeleton's addEntry method, it simply delegates the
invocation to the real implementation's addEntry method.
Besides the skeleton, WSDL2Java also generates an implementation template
from the binding:
public class AddressBookSOAPBindingImpl
implements AddressBook {
public void addEntry(String
name, Address address) throws java.rmi.RemoteException {
}
}
This template could actually be used as a test implementation but, as
you can see, it doesn't do anything. It is intended that the service
writer fill out the implementation from this template.
When WSDL2Java is asked to generate the implementation template (via
the --skeleton flag), it will ONLY generate it if it does not already exist.
If this implementation already exists, it will not be overwritten.
Services
The tool also builds you a "deploy.wsdd" and an "undeploy.wsdd" for each
service for use with the AdminClient. These files may be used to deploy
the service once you've filled in the methods of the Implementation class,
compiled the code, and made the classes available to your Axis engine.
Other WSDL2Java details
WSDL2Java has a number of options besides --skeleton.
Usage: java org.apache.axis.wsdl.WSDL2Java [options] WSDL-URI
Options:
-h, --help
print this message and exit
-v, --verbose
print informational messages
-s, --server-side
emit server-side bindings for web service
-S, --skeletonDeploy <argument>
deploy skeleton (true) or implementation (false) in deploy.wsdd.
Default is true. Assumes --server-side.
-N, --NStoPkg <argument>=<value>
mapping of namespace to package
-f, --fileNStoPkg <argument>
file of NStoPkg mappings (default NStoPkg.properties)
-p, --package <argument>
override all namespace to package mappings, use this package
name instead
-o, --output <argument>
output directory for emitted files
-d, --deployScope <argument>
add scope to deploy.xml: "Application", "Request", "Session"
-t, --testCase
emit junit testcase class for web service
-n, --noImports
only generate code for the immediate WSDL document
-a, --all
generate code for all elements, even unreferenced ones
-D, --Debug
print debug information
-T, --typeMappingVersion
<argument>
indicate 1.1 or 1.2. The default is 1.2 (SOAP 1.2 JAX-RPC c
ompliant)
-h, --help
Print the usage statement and exit
-v, --verbose
See what the tool is generating as it is generating it.
-s, --server-side
Emit the server-side bindings for the web service:
-
a skeleton class named <bindingName>Skeleton. This may or may
not be emitted (see -S, --skeletonDeploy).
-
an implementation template class named <bindingName>Impl. Note
that, if this class already exists, then it is not emitted.
-
deploy.wsdd
-
undeploy.wsdd
-S, --skeletonDeploy <argument>
Deploy either the skeleton (true) or the implementation (false) in deploy.wsdd.
In other words, for "true" the service clause in the deploy.wsdd file will
look something like:
<service name="AddressBook"
provider="java:RPC">
<parameter name="className" value="samples.addr.AddressBookSOAPBindingSkeleton"/>
...
</service>
and for "false" it would look like:
<service name="AddressBook" provider="java:RPC">
<parameter name="className" value="samples.addr.AddressBookSOAPBindingImpl"/>
...
</service>
The default for this option is true. When you use this option, the --server-side option is assumed, so you don't have to explicitly specify --server-side as well.
-N, --NStoPkg <argument>=<value>
By default, package names are generated from the namespace strings in the
WSDL document in a magical manner (typically, if the namespace is of the
form "http://x.y.com" or "urn:x.y.com" the corresponding package will be
"com.y.x"). If this magic is not what you want, you can provide your
own mapping using the --NStoPkg argument, which can be repeated as often
as necessary, once for each unique namespace mapping. For example,
if there is a namespace in the WSDL document called "urn:AddressFetcher2",
and you want files generated from the objects within this namespace to
reside in the package samples.addr, you would provide the following option
to Wsdl2java:
--NStoPkg urn:AddressFetcher2=samples.addr
(Note that if you use the short option tag, "-N", then there must not be
a space between "-N" and the namespace.)
-f, --fileNStoPkg <argument>
If there are a number of namespaces in the WSDL document, listing a mapping
for them all could become tedious. To help keep the command line
terse, WSDL2Java will also look for mappings in a properties file.
By default, this file is named "NStoPkg.properties" and it must reside
in the default package (ie., no package). But you can explicitly
provide your own file using the --fileNStoPkg option.
The entries in this file are of the same form as the arguments to the
--NStoPkg command line option. For example, instead of providing
the command line option as above, we could provide the same information
in NStoPkg.properties:
urn\:AddressFetcher2=samples.addr
(Note that the colon must be escaped in the properties file.)
If an entry for a given mapping exists both on the command line and
in the properties file, the command line entry takes precedence.
-p, --package <argument>
This is a shorthand option to map all namespaces in a WSDL document to
the same Java package name. This can be useful, but dangerous.
You must make sure that you understand the effects of doing this.
For instance there may be multiple types with the same name in different
namespaces. It is an error to use the --NStoPkg switch and --package
at the same time.
-o, --output <argument>
The root directory for all emitted files.
-d, --deployScope <argument>
Add scope to deploy.wsdd: "Application", "Request", or "Session".
If this option does not appear, no scope tag appears in deploy.wsdd, which
the AXIS runtime defaults to "Request".
-t, --testCase
Generate a client-side JUnit test case. This test case can stand
on its own, but it doesn't really do anything except pass default values
(null for objects, 0 or false for primitive types). Like the generated
implementation file, the generated test case file could be considered a
template that you may fill in.
-n, --noImports
Only generate code for the WSDL document that appears on the command line.
The default behaviour is to generate files for all WSDL documents, the
immediate one and all imported ones.
-a, --all
Generate code for all elements, even unreferenced ones. By default,
WSDL2Java only generates code for those elements in the WSDL file that
are referenced.
A note about what it means to be referenced. We cannot simply
say: start with the services, generate all bindings referenced by
the service, generated all portTypes referenced by the referenced bindings,
etc. What if we're generating code from a WSDL file that only contains
portTypes, messages, and types? If WSDL2Java used service as an anchor,
and there's no service in the file, then nothing will be generated.
So the anchor is the lowest element that exists in the WSDL file in the
order:
types
portTypes
bindings
services
For example, if a WSDL file only contained types, then all the listed
types would be generated. But if a WSDL file contained types and
a portType, then that portType will be generated and only those types that
are referenced by that portType.
-D, --Debug
Print debug information, which currently is WSDL2Java's symbol table.
-T, --typeMappingVersion <argument>
Indicate 1.1 or 1.2. The default is 1.2 (SOAP 1.2 JAX-RPC compliant).
Java2WSDL: Building WSDL
from Java
The Java2WSDL and WSDL2Java emitters make it easy to develop a new web service. The following sections describe the steps in building a web service from a Java interface.
Step 1: Provide a Java interface or class
Write and compile a Java interface (or class) that describes the web service
interface. Here is an example interface that describes a web services
that can be used to set/query the price of widgets (samples/userguide/example6/WidgetPrice.java):
package samples.userguide.example6;
/**
* Interface describing a web service
to set and get Widget prices.
**/
public interface WidgetPrice {
public void setWidgetPrice(String
widgetName, String price);
public String getWidgetPrice(String
widgetName);
}
Note: If you compile your class with debug information, Java2WSDL
will use the debug information to obtain the method parameter names.
Step 2: Create WSDL using Java2WSDL
Use the Java2WSDL tool to create a WSDL file from the interface above.
Here is an example invocation that produces the wsdl file (wp.wsdl)
from the interface described in the previous section:
% java org.apache.axis.wsdl.Java2WSDL -o wp.wsdl -l"http://localhost:8080/axis/services/WidgetPrice" -n "urn:Example6" -p"samples.userguide.example6" "urn:Example6" samples.userguide.example6.WidgetPrice
Where:
-
-o indicates the name of the output WSDL file
-
-l indicates the location of the service
-
-n is the target namespace of the WSDL file
-
-p indicates a mapping from the package to a namespace.
There may be multiple mappings.
-
the class specified contains the interface of the webservice.
The output WSDL document will contain the appropriate WSDL types, messages,
portType, bindings and service descriptions to support a SOAP rpc, encoding
web service. If your specified interface methods reference other
classes, the Java2WSDL tool will generate the appropriate xml types to
represent the classes and any nested/inherited types. The tool supports
JAX-RPC complex types (bean classes), extension classes, enumeration classes,
arrays and Holder classes.
The Java2WSDL tool has many additional options which are detailed in
the next section.
Java2WSDL Details
Here is the help message generated from the current tool:
Java2WSDL emitter
Usage: java org.apache.axis.wsdl.Java2WSDL
[options] class-of-portType
Options:
-h, --help
print this message and exit
-o, --output <argument>
output WSDL filename
-l, --location <argument>
service location url
-s, --service <argument>
service name (obtained from --location if not specified)
-n, --namespace <argument>
target namespace
-p, --PkgtoNS <argument>=<value>
package=namespace, name value pairs
-m, --methods <argument>
space or comma separated list of methods to export
-a, --all
look for allowed methods in inherited class
-w, --outputWsdlMode <argument>
output WSDL mode: All, Interface, Implementation
-L, --locationImport <argument>
location of interface WSDL
-N, --namespaceImpl <argument>
target namespace for implementation WSDL
-O, --outputImpl <argument>
output Implementation WSDL filename, setting this causes --outputWsdlMode
to be ignored
-f, --factory <argument>
name of the Java2WSDLFactory class for extending WSDL generation functions
-i, --implClass <argument>
optional class that contains implementation of methods in
class-of-portType. The debug information in the class is used
to obtain the method parameter names, which are used to set
the WSDL part names.
Details:
portType name=
<class-of-portType name>
binding
name= <--service value>SoapBinding
service
name= <--service value>Service
port
name= <--service value>
address location= <--location
value>
-h , --help
Prints the help message.
-o, --output <WSDL file>
Indicates the name of the output WSDL file. If not specified,
a suitable default WSDL file is written into the current directory.
-l, --location <location>
Indicates the url of the location of the service. The name after
the last slash or backslash is the name of the service port (unless overriden
by the -s option). The service port address location attributed is
assigned the specified value.
-s, -service <name>
Indicates the name of the service. If not specified, the service
name is derived from the --location value. The names of the WSDL
binding, service, and port elements are derived from the service name as
indicated in the Details section
above.
-n, --namespace <target namespace>
Indicates the name of the target namespace of the WSDL.
-p, --PkgToNS <package> <namespace>
Indicates the mapping of a package to a namespace. If a package
is encountered that does not have a namespace, the Java2WSDL emitter will
generate a suitable namespace name. This option may be specified
multiple times.
-m, --methods <arguments>
If this option is specified, only the indicated methods in your interface
class will be exported into the WSDL file. The methods list must
be comma separated. If not specified, all methods declared in the
interface class will be exported into the WSDL file.
-a, --all
If this option is specified, the Java2WSDL parser will look into extended
classes to determine the list of methods to export into the WSDL file.
-w, --outputWSDLMode <mode>
Indicates the kind of WSDL to generate. Accepted values are:
-
All --- (default) Generates wsld containing both interface and implementation
WSDL constructs.
-
Interface --- Generates a WSDL containing the interface constructs (no
service element).
-
Implementation -- Generates a WSDL containing the implementation.
The interface WSDL is imported via the -L option.
-L, --locationImport <url>
Used to indicate the location of the interface WSDL when generating
an implementation WSDL.
-N, --namespaceImpl <namespace>
Namespace of the implementation WSDL.
-O, --outputImpl <WSDL file>
Use this option to indicate the name of the output implementation WSDL
file. If specified, Java2WSDL will produce interface and implementation
WSDL files. If this option is used, the -w option is ignored.
-f, --factory <class>
Use this expert option to extend and customize the WSDL2Java tool.
-i, --implClass <impl-class>
The Java2WSLD tool uses method parameter names to construct the WSDL
message part names. The message names are obtained from the debug
information of the <class-of-portType> class file. If that
class file was compiled without debug information or if <class-of-portType>
is an interface, the method parameter names are not available. In
these cases, you can use the --implClass option to provide an alternative
class from which to obtain method parameter names. The <impl-class>
could be the actual implementation class, a stub class or a skeleton class.
Step 3: Create Bindings using WSDL2Java
Use the generated WSDL file to build the appropriate client/server bindings
for the web service (see WSDL2Java):
% java org.apache.axis.wsdl.Wsdl2java -o . -d session -s -Nurn:Example6 samples.userguide.example6 ws.wsdl
This will generate the following files:
-
WidgetPriceSoapBindingImpl.java : Java file containing
the default server implementation of the WidgetPrice web service.
You will need to modify the *SoapBindingImpl file to add your implementation
(see ../samples/userguide/example6/WidgetPriceSoapBindingImpl.java
).
-
WidgetPrice.java: New interface file that contains
the appropriate java.rmi.Remote usages.
-
WidgetPriceService.java: Java file containing the client
side service class.
-
WidgetPriceSoapBindingSkeleton.java: Server side skeleton.
-
WidgetPriceSoapBindingStub.java: Client side stub.
-
deploy.xml: Deployment descriptors
-
undeploy.xml: Undeploy descriptors
-
(data types): Java files will be produced for all of the other types
and holders necessary for the web service. There are no additional
files for the WidgetPrice web service.
Now you have all of the necessary files to build your client/server side
code and deploy the web service!
Published Axis Interfaces
Although you may use any of the interfaces and classes present in Axis, you need to
be aware that some are more stable than others since there is a continuing
need to refactor Axis to maintain and improve its modularity.
Hence certain interfaces are designated as published, which means
that they are relatively stable. As Axis is refactored, the Axis developers
will try to avoid changing published interfaces unnecessarily and will
certainly consider the impact on users of any modifications.
So if you stick to using only published interfaces, you'll minimise
the pain of migrating between releases of Axis. On the other hand, if you
decide to use unpublished interfaces, migrating between releases could
be an interesting exercise! If you would like an interface to be published,
you should make the case for this on the
axis-user
mailing list.
The current list of published interfaces is as follows:
-
JAX-RPC interfaces. At the time of this writing, JAX-RPC is still in the public review stage of its existence, meaning that it may still change. As it does, the JAX-RPC interfaces may also change. JAX-RPC is expected to become official some time during the summer of 2002.
- javax.xml.messaging.Endpoint
- javax.xml.messaging.URLEndpoint
- javax.xml.rpc.Call
- javax.xml.rpc.FaultException
- javax.xml.rpc.JAXRPCException
- javax.xml.rpc.ParameterMode
- javax.xml.rpc.Service
- javax.xml.rpc.ServiceException
- javax.xml.rpc.ServiceFactory
- javax.xml.rpc.Stub
- javax.xml.rpc.encoding.DeserializationContext
- javax.xml.rpc.encoding.Deserializer
- javax.xml.rpc.encoding.DeserializerFactory
- javax.xml.rpc.encoding.SerializationContext
- javax.xml.rpc.encoding.Serializer
- javax.xml.rpc.encoding.SerializerFactory
- javax.xml.rpc.encoding.TypeMapping
- javax.xml.rpc.encoding.TypeMappingRegistry
- javax.xml.rpc.handler.Handler
- javax.xml.rpc.handler.HandlerChain
- javax.xml.rpc.handler.HandlerInfo
- javax.xml.rpc.handler.HandlerRegistry
- javax.xml.rpc.handler.MessageContext
- javax.xml.rpc.handler.soap.SOAPMessageContext
- javax.xml.rpc.holders.BigDecimalHolder
- javax.xml.rpc.holders.BigIntegerHolder
- javax.xml.rpc.holders.BooleanHolder
- javax.xml.rpc.holders.BooleanWrapperHolder
- javax.xml.rpc.holders.ByteArrayHolder
- javax.xml.rpc.holders.ByteHolder
- javax.xml.rpc.holders.ByteWrapperArrayHolder
- javax.xml.rpc.holders.ByteWrapperHolder
- javax.xml.rpc.holders.CalendarHolder
- javax.xml.rpc.holders.DateHolder
- javax.xml.rpc.holders.DoubleHolder
- javax.xml.rpc.holders.DoubleWrapperHolder
- javax.xml.rpc.holders.FloatHolder
- javax.xml.rpc.holders.FloatWrapperHolder
- javax.xml.rpc.holders.Holder
- javax.xml.rpc.holders.IntHolder
- javax.xml.rpc.holders.IntegerWrapperHolder
- javax.xml.rpc.holders.LongHolder
- javax.xml.rpc.holders.LongWrapperHolder
- javax.xml.rpc.holders.ObjectHolder
- javax.xml.rpc.holders.QNameHolder
- javax.xml.rpc.holders.ShortHolder
- javax.xml.rpc.holders.ShortWrapperHolder
- javax.xml.rpc.holders.StringHolder
- javax.xml.rpc.namespace.QName
- javax.xml.rpc.server.ServiceLifecycle
- javax.xml.rpc.soap.SOAPFault
- javax.xml.rpc.soap.SOAPHeaderFault
- javax.xml.transform.Source
- AXIS interfaces:
- org.apache.axis.AxisFault
- org.apache.axis.Handler
- org.apache.axis.DefaultEngineConfigurationFactory
- org.apache.axis.EngineConfiguration
- org.apache.axis.EngineConfigurationFactory
- org.apache.axis.Message
- org.apache.axis.MessageContext
- org.apache.axis.SOAPPart
- org.apache.axis.client.Call
- org.apache.axis.client.Service
- org.apache.axis.client.ServiceFactory
- org.apache.axis.client.Stub
- org.apache.axis.client.Transport
- org.apache.axis.description.TypeDesc
- org.apache.axis.description.AttributeDesc
- org.apache.aixs.description.ElementDesc
- org.apache.axis.encoding.SerializationContext
- org.apache.axis.session.Session
- org.apache.axis.transport.http.SimpleAxisServer
- org.apache.axis.wsdl.WSDL2Java
- org.apache.axis.wsdl.Java2WSDL
Using the Axis TCP Monitor (tcpmon)
The included "tcpmon" utility can be found in the org.apache.axis.utils
package. To run it from the command line:
% java org.apache.axis.utils.tcpmon [listenPort targetHost targetPort]
Without any of the optional arguments, you will get a gui which looks like
this:
To use the program, you should select a local port which tcpmon will
monitor for incoming connections, a target host where it will forward such
connections, and the port number on the target machine which should be
"tunneled" to. Then click "add". You should then notice another tab appearing
in the window for your new tunneled connection. Looking at that panel,
you'll see something like this:
Now each time a SOAP connection is made to the local port, you will
see the request appear in the "Request" panel, and the response from the
server in the "Response" panel. Tcpmon keeps a log of all request/response
pairs, and allows you to view any particular pair by selecting an entry
in the top panel. You may also remove selected entries, or all of them,
or choose to save to a file for later viewing.
The "resend" button will resend the request you are currently viewing,
and record a new response. This is particularly handy in that you can edit
the XML in the request window before resending - so you can use this as
a great tool for testing the effects of different XML on SOAP servers.
Note that you may need to change the content-length HTTP header value
before resending an edited request.
-
Glossary
-
Handler
-
<definition>
-
SOAP
-
The Simple Object Access Protocol (yes, despite the fact that it sometimes
doesn't seem so simple, and doesn't have anything to do with objects...
:)). You can read the SOAP 1.1 specification at http://www.w3.org/TR/SOAP.
The W3C is currently in the midst of work on SOAP 1.2, under the auspices
of the XML Protocol Group.
-
Provider
-
<definition>
-


PEACE TEA SUSTAINABILITY CAMPAIGN
Sustainability is the idea that any process whether it be biological or business should not take more out of an ecosystem than which can be replaced. Recently this has been becoming an important trend in the business world. Peace Tea is a brand whose built it image off of a nostalgic 1960s counter culture vibe so it's only reasonable that they would want to associate themselves with such a movement.
The campaign is designed to promote internal awareness of the topic within the company. As a result a sub-brand "Peacing it Together" was created. To go along with the sub brand a storyboard for a motion graphic was created as well as a poster to be displayed in public areas and break rooms.


"CARVE" The arts of engraving and carving were much practised among the Jews. They were practised in connection with the construction of the tabernacle and the temple (Exodus 31:2, 5; 35:33; 1 Kings 6:18, 35; Psalm 74:6), as well as in the ornamentation of the priestly dresses (Exodus 28:9-36; Zechariah 3:9; 2 Chronicles 2:7, 14). Isaiah (44:13-17) gives a minute description of the process of carving idols of wood.
"CARVE" The arts of engraving and carving were much practised among the Jews. They were practised in connection with the construction of the tabernacle and the temple (Exodus 31:2, 5; 35:33; 1 Kings 6:18, 35; Psalm 74:6), as well as in the ornamentation of the priestly dresses (Exodus 28:9-36; Zechariah 3:9; 2 Chronicles 2:7, 14). Isaiah (44:13-17) gives a minute description of the process of carving idols of wood.


Iyengar’s Home Products [IHP] is serving people from 29 long years with its food product Iyengar puliogare or tamarind rice. Puliogare is an ancient Indian dish. It is prepared by using fire wood in a traditional way. In order to prepare Puliyogare we use tamarind & jaggary paste to that add all masala items fried & mixed to that paste in appropriate manner.
We take meticulous care right from sourcing raw materials, to testing, processing to production and packaging to branding. At every step, quality is ensured with perfection which gives it a higher nutritional value.The organization always aims at providing people with the best quality product at an economic price where anyone can afford to buy it and is very easy to prepare, quick to make besides, it has always maintained its superior quality and taste.
Needless to mention, as it contains highest nutritional value, almost every child and office goers likes it. It has retained the grandma’s homely taste. Most of the schools and college students, including hostels, apart from large number of small and big hotels in Karnataka regularly use our Puliyogare, which is easily accessible to them in the nearest shops and outlets at affordable prices.
Our Iyengar Puliyogare are in the Variants of 40 grams, 100 grams and 200 grams, nicely packed with highest standards. Our selling prices are as follows:
| Weight | Price |
| 40 gm | Rs. 10 |
| 100 gm | Rs. 25 |
| 200 gm | Rs. 50 |
Founder Dwarakanath B.K, a man who started with nothing and reached to everything. He believed that health is the main purpose for which a man earns, and helath is influenced by food. So,intiated providing healthy food to people at an affordable price that can be instantly preapred.A man with immense thought to serve people in need.
Apart from business, he also strongly believes in giving back to the society. Being a great follower of Swami Vivekananda, He desires the Indian culture to be followed and nourished in the future by today’s youth who are more influenced by the western culture. He has undertaken various ventures to accomplish tasks which make the Indian culture flourish. “Arise awake”, “stop not till your goal is reached”, books by Swami Vivekananda, 1000s of “ Bhagavadgeeta” books has been distributed to the public free of cost to motivate the youths and awaken people about culture. He has been a motivation and inspiration to many people.
He strongly believes in the “Live and let live principle”, where he insists every person to be a giver, not a taker. He has undergone various food processing trainings at CFTRI, Mysore. He believes in preparing food with best quality materials taking extreme care in every step, not to lose its taste and flavour.


AdmitHTTP — Data browser services module.¶
This module defines the classes needed to serve ADMIT data to the data browser on a localhost port. These classes are subclasses of those provided in the Python library BaseHTTPServer module.
-
class
admit.util.AdmitHTTP.
AdmitHTTPServer
(server_address, docroot, postcallback)[source]¶ - This class is identical to BaseHTTPServer.HTTPServer except
- It defines a fixed document root instead of using the current working directory.
- The handler class is fixed to be AdmitHTTPRequestHandler.
This is accomplished by overriding the constructor and BaseServer.finish_request().
Parameters: server_address : tuple
The address on which the server is listening. This is a tuple containing a string giving the address, and an integer port number: (‘<IP_ADDRESS>’, 80), for example.
docroot : string
The document root directory for the local data web server. Requests will be served out of this directory. ** todo: possibly make this always localhost**
postcallback : function
The external function to call when handling a POST.
Attributes
_documentRoot (string) The document root directory for the web server. Requests will be served out of this directory. Methods
close_request
(request)Called to clean up an individual request. fileno
()Return socket file number. finish_request
(request, client_address)Finish one http request by instantiating RequestHandlerClass. get_request
()Get the request and client address from the socket. handle_error
(request, client_address)Handle an error gracefully. handle_request
()Handle one request, possibly blocking. handle_timeout
()Called if no new request arrives within self.timeout. process_request
(request, client_address)Call finish_request. serve_forever
([poll_interval])Handle one request at a time until shutdown. server_activate
()Called by constructor to activate the server. server_bind
()Override server_bind to store the server name. server_close
()Called to clean-up the server. shutdown
()Stops the serve_forever loop. shutdown_request
(request)Called to shutdown and close an individual request. verify_request
(request, client_address)Verify the request. -
finish_request
(request, client_address)[source]¶ Finish one http request by instantiating RequestHandlerClass. Construction of the handler class calls the methods to process the request. overrides: BaseServer.finish_request
-
class
admit.util.AdmitHTTP.
AdmitHTTPRequestHandler
(request, client_address, docroot, postcallback)[source]¶ And HTTP request handler that allows a fixed document root. Python’s SimpleHTTPRequestHandler always uses the current working directory which is stored globally. Therefore, SimpleHTTPRequestHandler cannot be used to spawn off http servers in separate threads because they will overwrite each other’s working directories.
Attributes
timeout Methods
MessageClass
alias of Message
address_string
()Return the client address formatted for logging. copyfile
(source, outputfile)Copy all data between two file objects. date_time_string
([timestamp])Return the current date and time formatted for a message header. do_GET
()Serve a GET request. do_HEAD
()Serve a HEAD request. do_OPTIONS
()do_POST
()end_headers
()Send the blank line ending the MIME headers. finish
()guess_type
(path)Guess the type of a file. handle
()Handle multiple requests if necessary. handle_error
(request, client_address)handle_one_request
()Handle a single HTTP request. isFirefox
()Attempt to detect the Firefox browser. is_broken_pipe_error
()list_directory
(path)Helper to produce a directory listing (absent index.html). log_date_time_string
()Return the current time formatted for logging. log_error
(format, \*args)Log an error. log_message
(format, \*args)log_request
([code, size])Log an accepted request. parse_request
()Parse a request (internal). send_error
(code[, message])Send and log an error reply. send_head
()Common code for GET and HEAD commands. send_header
(keyword, value)Send a MIME header. send_response
(code[, message])Send the response header and log the response code. setup
()translate_path
(path)Translate a /-separated PATH to the local filename syntax. version_string
()Return the server software version string. -
isFirefox
()[source]¶ Attempt to detect the Firefox browser. This is because Firefox does funny things and we have to workaround it. Return True if the user-agent header contains the string ‘firefox’ (case insensitive)
-
translate_path
(path)[source]¶ Translate a /-separated PATH to the local filename syntax. Components that mean special things to the local file system (e.g. drive or directory names) are ignored. This method is identical to SimpleHTTPRequestHandler.translate_path() except it uses the locally stored document root instead of the current working directory.
-