\section{IHeader\-Block Class Reference}
\label{classIHeaderBlock}\index{IHeaderBlock@{IHeaderBlock}}
interface for the IHeader\-Block class. 


{\tt \#include $<$IHeader\-Block.h$>$}

Inheritance diagram for IHeader\-Block::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=2cm]{classIHeaderBlock}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
virtual int {\bf get\-No\-Of\-Children} ()=0
\item 
virtual Basic\-Node $\ast$ {\bf create\-Child} (NODE\_\-TYPE e\-NODE\_\-TYPE, Axis\-Char $\ast$pach\-Local\-Name, Axis\-Char $\ast$pach\-Prefix, Axis\-Char $\ast$pach\-Uri, Axis\-Char $\ast$pach\-Value)=0
\item 
virtual Basic\-Node $\ast$ {\bf create\-Immediate\-Child} (NODE\_\-TYPE e\-NODE\_\-TYPE, Axis\-Char $\ast$pach\-Local\-Name, Axis\-Char $\ast$pach\-Prefix, Axis\-Char $\ast$pach\-Uri, Axis\-Char $\ast$pach\-Value)=0
\item 
virtual {\bf Attribute} $\ast$ {\bf create\-Std\-Attribute} (HEADER\_\-BLOCK\_\-STD\_\-ATTR\_\-TYPE e\-Std\-Attr\-Type, SOAP\_\-VERSION e\-SOAP\_\-VERSION)=0
\item 
virtual {\bf Attribute} $\ast$ {\bf create\-Attribute} (const Axis\-Char $\ast$localname, const Axis\-Char $\ast$prefix, const Axis\-Char $\ast$uri, const Axis\-Char $\ast$value)=0
\item 
virtual {\bf Attribute} $\ast$ {\bf create\-Attribute} (const Axis\-Char $\ast$localname, const Axis\-Char $\ast$prefix, const Axis\-Char $\ast$value)=0
\item 
virtual Basic\-Node $\ast$ {\bf create\-Immediate\-Child} (NODE\_\-TYPE e\-NODE\_\-TYPE)=0
\item 
virtual Basic\-Node $\ast$ {\bf create\-Child} (NODE\_\-TYPE e\-NODE\_\-TYPE)=0
\item 
virtual const Basic\-Node $\ast$ {\bf get\-Last\-Child} ()=0
\item 
virtual const Basic\-Node $\ast$ {\bf get\-Child} (int i\-Child\-Position)=0
\item 
virtual int {\bf add\-Child} (Basic\-Node $\ast$p\-Basic\-Node)=0
\item 
virtual void {\bf set\-Local\-Name} (const Axis\-Char $\ast$localname)=0
\item 
virtual void {\bf set\-Uri} (const Axis\-Char $\ast$uri)=0
\item 
virtual int {\bf initialize\-For\-Testing} ()=0
\item 
virtual IHeader\-Block $\ast$ {\bf clone} ()=0
\item 
virtual {\bf $\sim$IHeader\-Block} ()
\end{CompactItemize}


\subsection{Detailed Description}
interface for the IHeader\-Block class.

\begin{Desc}
\item[Author: ]\par
Roshan Weerasuriya ({\tt roshan@opensource.lk}, {\tt roshanw@jkcsworld.com}) , Samisa Abeysinghe ({\tt sabeysinghe@virtusa.com}) , Susantha Kumara ({\tt susantha@opensource.lk}, {\tt skumara@virtusa.com}) \end{Desc}




\subsection{Constructor \& Destructor Documentation}
\index{IHeaderBlock@{IHeader\-Block}!~IHeaderBlock@{$\sim$IHeaderBlock}}
\index{~IHeaderBlock@{$\sim$IHeaderBlock}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual IHeader\-Block::$\sim$IHeader\-Block ()\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classIHeaderBlock_a18}


The Destructor. 

\subsection{Member Function Documentation}
\index{IHeaderBlock@{IHeader\-Block}!addChild@{addChild}}
\index{addChild@{addChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual int IHeader\-Block::add\-Child (Basic\-Node $\ast$ {\em p\-Basic\-Node})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a11}


Adds a child node to the Header Block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
p\-Basic\-Node}]The child node pointer which is to be added. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
AXIS\_\-SUCCESS to indicate successfull operation. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!clone@{clone}}
\index{clone@{clone}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual IHeader\-Block$\ast$ IHeader\-Block::clone ()\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a17}


Creates and returns a clone of this Header Block.

\begin{Desc}
\item[Returns: ]\par
A clone of this Header Block. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createAttribute@{createAttribute}}
\index{createAttribute@{createAttribute}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf Attribute}$\ast$ IHeader\-Block::create\-Attribute (const Axis\-Char $\ast$ {\em localname}, const Axis\-Char $\ast$ {\em prefix}, const Axis\-Char $\ast$ {\em value})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a6}


Creates a {\bf Attribute} {\rm (p.\,\pageref{classAttribute})} and adds it to this Header Block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
localname}]The local name of the attribute. \item[{\em 
prefix}]The prefix of the attribute. \item[{\em 
value}]The value of the attribute.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
A pointer to the created {\bf Attribute} {\rm (p.\,\pageref{classAttribute})} will be returned. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createAttribute@{createAttribute}}
\index{createAttribute@{createAttribute}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf Attribute}$\ast$ IHeader\-Block::create\-Attribute (const Axis\-Char $\ast$ {\em localname}, const Axis\-Char $\ast$ {\em prefix}, const Axis\-Char $\ast$ {\em uri}, const Axis\-Char $\ast$ {\em value})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a5}


Creates a {\bf Attribute} {\rm (p.\,\pageref{classAttribute})} and adds it to this Header Block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
localname}]The local name of the attribute. \item[{\em 
prefix}]The prefix of the attribute. \item[{\em 
uri}]The namespace uri of the attribute. \item[{\em 
value}]The value of the attribute.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
A pointer to the created {\bf Attribute} {\rm (p.\,\pageref{classAttribute})} will be returned. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createChild@{createChild}}
\index{createChild@{createChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual Basic\-Node$\ast$ IHeader\-Block::create\-Child (NODE\_\-TYPE {\em e\-NODE\_\-TYPE})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a8}


Creates a child node depending on the given type. If the type is  CHARACTER\_\-NODE a {\bf Character\-Element} {\rm (p.\,\pageref{classCharacterElement})} is created. If the type is  ELEMENT\_\-NODE a {\bf Complex\-Element} {\rm (p.\,\pageref{classComplexElement})} is created. After creating the child it will not be added as a child to the header block. The user has to add the created child to the appropriate locaion as his wish.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
e\-NODE\_\-TYPE}]The type of the child to be created,  it should be either  CHARACTER\_\-NODE for Character\-Elements or ELEMENT\_\-NODE for  Complex\-Elements. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
The child node created will be returned if the creation is successfull. If the creation is unsccessfull it will return NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createChild@{createChild}}
\index{createChild@{createChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual Basic\-Node$\ast$ IHeader\-Block::create\-Child (NODE\_\-TYPE {\em e\-NODE\_\-TYPE}, Axis\-Char $\ast$ {\em pach\-Local\-Name}, Axis\-Char $\ast$ {\em pach\-Prefix}, Axis\-Char $\ast$ {\em pach\-Uri}, Axis\-Char $\ast$ {\em pach\-Value})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a2}


Creates a child node depending on the given node type. i.e: if node type == CHARACTER\_\-NODE then it creates a Character Element. if node type == ELEMENT\_\-NODE then it creates a Complex Element. This method doesn't add the created child to this Header Block. If the user needs to add this created child then he has to use the {\bf add\-Child(Basic\-Node $\ast$p\-Basic\-Node)} {\rm (p.\,\pageref{classIHeaderBlock_a11})} method after creating the child. If the node to be created is a CHARACTER\_\-NODE then only the parameter pach\-Value will be usefull and for others you can provide NULL. If the node to be created is a ELEMENT\_\-NODE then the parameters  pach\-Local\-Name, pach\-Prefix, pach\-Uri will be needed to provide and you can provide NULL for the pach\-Value.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
e\-NODE\_\-TYPE}]The node type to be created, i.e CHARACTER\_\-NODE or ELEMENT\_\-NODE. \item[{\em 
pach\-Local\-Name}]The local name of the child node. A CHARACTER\_\-NODE will ignore this. \item[{\em 
pach\-Prefix}]The prefix of the child node. A CHARACTER\_\-NODE will ignore this. \item[{\em 
pach\-Uri}]The namespace uri of the child node. A CHARACTER\_\-NODE will ignore this. \item[{\em 
pach\-Value}]The value of the child node. A ELEMENT\_\-NODE will ignore this.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
The child node created will be returned if the creation is successfull. If the creation is unsccessfull it will return NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createImmediateChild@{createImmediateChild}}
\index{createImmediateChild@{createImmediateChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual Basic\-Node$\ast$ IHeader\-Block::create\-Immediate\-Child (NODE\_\-TYPE {\em e\-NODE\_\-TYPE})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a7}


Creates a child node depending on the given type. If the type is  CHARACTER\_\-NODE a {\bf Character\-Element} {\rm (p.\,\pageref{classCharacterElement})} is created. If the type is  ELEMENT\_\-NODE a {\bf Complex\-Element} {\rm (p.\,\pageref{classComplexElement})} is created. After creating the child it will be added as a immediate child to the header block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
The}]type of the child to be created, it should be either  CHARACTER\_\-NODE for Character\-Elements or ELEMENT\_\-NODE for  Complex\-Elements. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
The child node created will be returned if the creation is successfull. If the creation is unsccessfull it will return NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createImmediateChild@{createImmediateChild}}
\index{createImmediateChild@{createImmediateChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual Basic\-Node$\ast$ IHeader\-Block::create\-Immediate\-Child (NODE\_\-TYPE {\em e\-NODE\_\-TYPE}, Axis\-Char $\ast$ {\em pach\-Local\-Name}, Axis\-Char $\ast$ {\em pach\-Prefix}, Axis\-Char $\ast$ {\em pach\-Uri}, Axis\-Char $\ast$ {\em pach\-Value})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a3}


Creates a child node depending on the given type. If the type is  CHARACTER\_\-NODE a {\bf Character\-Element} {\rm (p.\,\pageref{classCharacterElement})} is created. If the type is  ELEMENT\_\-NODE a {\bf Complex\-Element} {\rm (p.\,\pageref{classComplexElement})} is created. After creating the child it will be added as a immediate child to the header block. It is important to note that if the type is CHARACTER\_\-NODE only the NODE\_\-TYPE and value (pach\-Value) parameters will be usefull.If the type is ELEMENT\_\-NODE the parameters NODE\_\-TYPE, pach\-Local\-Name, pach\-Prefix,  pach\-Uri will be usefull.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
e\-NODE\_\-TYPE}]The type of the child to be created, it should be either  CHARACTER\_\-NODE for Character\-Elements or ELEMENT\_\-NODE for  Complex\-Elements. \item[{\em 
pach\-Local\-Name}]The local name of the complex element to be created. \item[{\em 
pach\-Prefix}]The prefix of the complex element to be created. \item[{\em 
pach\-Uri}]The namespace uri of the complex element to be created. \item[{\em 
pach\-Value}]The value of the character element to be created.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
The child node created will be returned if the creation is successfull. If the creation is unsccessfull it will return NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!createStdAttribute@{createStdAttribute}}
\index{createStdAttribute@{createStdAttribute}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf Attribute}$\ast$ IHeader\-Block::create\-Std\-Attribute (HEADER\_\-BLOCK\_\-STD\_\-ATTR\_\-TYPE {\em e\-Std\-Attr\-Type}, SOAP\_\-VERSION {\em e\-SOAP\_\-VERSION})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a4}


A user can use this method to create a standard Header\-Block attribute.  The types of HEADER\_\-BLOCK\_\-STD\_\-ATTR\_\-TYPE are: ROLE\_\-NEXT : To create the role attribute to point to next. ROLE\_\-NONE : To create the role attribute to point to none. ROLE\_\-ULTIMATE\_\-RECEIVER : To create the role attribute to point to  ultimate receiver. ACTOR : To create the actor attribute to point to next. MUST\_\-UNDERSTAND\_\-TRUE : To create the must\-Understand attribute to  point to true. MUST\_\-UNDERSTAND\_\-FALSE : To create the must\-Understand attribute to  point to false. To use ROLE\_\-NEXT,  ROLE\_\-NONE, ROLE\_\-ULTIMATE\_\-RECEIVER, MUST\_\-UNDERSTAND\_\-TRUE, MUST\_\-UNDERSTAND\_\-FALSE the user has to pass SOAP\_\-VER\_\-1\_\-2 as the  SOAP\_\-VERSION. To use ACTOR, MUST\_\-UNDERSTAND\_\-TRUE, MUST\_\-UNDERSTAND\_\-FALSE the user has  to pass SOAP\_\-VER\_\-1\_\-1 as the SOAP\_\-VERSION.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
e\-Std\-Attr\-Type}]The standard attribute to be created. The current values that can be passes are: ROLE\_\-NEXT, ROLE\_\-NONE,  ROLE\_\-ULTIMATE\_\-RECEIVER, ACTOR, MUST\_\-UNDERSTAND\_\-TRUE, MUST\_\-UNDERSTAND\_\-FALSE. \item[{\em 
e\-SOAP\_\-VERSION}]The related soap version.  The vallues which could be passes are SOAP\_\-VER\_\-1\_\-1 and SOAP\_\-VER\_\-1\_\-2.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
A pointer to the created standard {\bf Attribute} {\rm (p.\,\pageref{classAttribute})} will be returned. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!getChild@{getChild}}
\index{getChild@{getChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual const Basic\-Node$\ast$ IHeader\-Block::get\-Child (int {\em i\-Child\-Position})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a10}


Returns the child element at the given postion.  The user has to check whether the method return NULL before proceding.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
i\-Child\-Position}]The positon of the required child element. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns: ]\par
The required child element is returned if it exists.  If the child element doesn't exsist this method returns NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!getLastChild@{getLastChild}}
\index{getLastChild@{getLastChild}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual const Basic\-Node$\ast$ IHeader\-Block::get\-Last\-Child ()\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a9}


Returns the last child element. The user has to check whether the method return NULL before proceding.

\begin{Desc}
\item[Returns: ]\par
The last child element is returned if it exists.  If the child element doesn't exsist this method returns NULL. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!getNoOfChildren@{getNoOfChildren}}
\index{getNoOfChildren@{getNoOfChildren}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual int IHeader\-Block::get\-No\-Of\-Children ()\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a1}


Returns the number of child elements of this Header\-Block.

\begin{Desc}
\item[Returns: ]\par
The number of child elements of this Header\-Block. \end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!initializeForTesting@{initializeForTesting}}
\index{initializeForTesting@{initializeForTesting}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual int IHeader\-Block::initialize\-For\-Testing ()\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a14}


Initialized the Header Block for testing. \index{IHeaderBlock@{IHeader\-Block}!setLocalName@{setLocalName}}
\index{setLocalName@{setLocalName}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void IHeader\-Block::set\-Local\-Name (const Axis\-Char $\ast$ {\em localname})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a12}


Sets the local name of this Header Block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
localname}]The localname to set in. \end{description}
\end{Desc}
\index{IHeaderBlock@{IHeader\-Block}!setUri@{setUri}}
\index{setUri@{setUri}!IHeaderBlock@{IHeader\-Block}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void IHeader\-Block::set\-Uri (const Axis\-Char $\ast$ {\em uri})\hspace{0.3cm}{\tt  [pure virtual]}}\label{classIHeaderBlock_a13}


Sets the namespace uri of this Header Block.\begin{Desc}
\item[Parameters: ]\par
\begin{description}
\item[{\em 
uri}]The namespace uri to set in. \end{description}
\end{Desc}


The documentation for this class was generated from the following file:\begin{CompactItemize}
\item 
IHeader\-Block.h\end{CompactItemize}
