\hypertarget{classCompoundUserInfo}{
\section{CompoundUserInfo$<$ T $>$ Class Template Reference}
\label{classCompoundUserInfo}\index{CompoundUserInfo@{CompoundUserInfo}}
}
The main userinfo template class. You should derive this class whenever you need a new userinfo of a class which is compound from smaller elements (all having its own userinfo class prepared).  


{\tt \#include $<$userinfo.h$>$}

Inheritance diagram for CompoundUserInfo$<$ T $>$:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=179pt]{classCompoundUserInfo__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for CompoundUserInfo$<$ T $>$:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=137pt]{classCompoundUserInfo__coll__graph}
\end{center}
\end{figure}
\subsection*{Static Public Member Functions}
\begin{CompactItemize}
\item 
{\footnotesize template$<$class T$>$ }\\static T $\ast$ \hyperlink{classUserInfo_0f090c6525a3e8fb11634a553f467ede}{Assembly} (DOMElement \&element, const string tagName)
\item 
{\footnotesize template$<$class T$>$ }\\static bool \hyperlink{classUserInfo_1d402661b82feccb5265a70f65c242e1}{Disassembly} (T \&\hyperlink{classTypedUserInfo_c7ad10a9ff002383518155c965ade85c}{instance}, DOMElement \&element, const string tagName, const string help)
\item 
{\footnotesize template$<$class T$>$ }\\static bool \hyperlink{classUserInfo_917b2257abc31b94c89ef3cd270e4a42}{Disassembly} (T \&\hyperlink{classTypedUserInfo_c7ad10a9ff002383518155c965ade85c}{instance}, DOMElement \&element, const string tagName)
\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
\hypertarget{classCompoundUserInfo_e2265e447e2f48550c5d8d479119bbb3}{
\textbf{CompoundUserInfo} (string userFriendlyTypeName)}
\label{classCompoundUserInfo_e2265e447e2f48550c5d8d479119bbb3}

\item 
\hypertarget{classBindingFrame_2244bd5181c3d1e70f3a6be2b72e9424}{
string \hyperlink{classBindingFrame_2244bd5181c3d1e70f3a6be2b72e9424}{XMLCh2str} (const XMLCh $\ast$const XMLCh\_\-str)}
\label{classBindingFrame_2244bd5181c3d1e70f3a6be2b72e9424}

\begin{CompactList}\small\item\em function which transcodes Xerces' XMLCh-based strings into C++ strings \item\end{CompactList}\item 
\hypertarget{classBindingFrame_820e4df85c0dc545e3079e407fcdbbaa}{
string \textbf{removeSpaces} (const string \&str)}
\label{classBindingFrame_820e4df85c0dc545e3079e407fcdbbaa}

\end{CompactItemize}
\subsection*{Static Protected Attributes}
\begin{CompactItemize}
\item 
static const \hyperlink{classTypedUserInfo}{TypedUserInfo}$<$ T $>$ \& \hyperlink{classTypedUserInfo_c7ad10a9ff002383518155c965ade85c}{instance}
\end{CompactItemize}
\subsection*{Classes}
\begin{CompactItemize}
\item 
class \hyperlink{classCompoundUserInfo_1_1BindedElement}{BindedElement}
\begin{CompactList}\small\item\em Templated class binding inner element with its XML tag and automating data transfers in both directions. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
\subsubsection*{template$<$typename T$>$ class CompoundUserInfo$<$ T $>$}

The main userinfo template class. You should derive this class whenever you need a new userinfo of a class which is compound from smaller elements (all having its own userinfo class prepared). 

To bind some inner element to its own userinfo class, and also to automate its assembling and disassembling, it is necessary to create a instance of an inner templated class BindedElement$<$T$>$. Those attributes have to be initialized in constructor of a new compound userinfo this way:



\begin{Code}\begin{verbatim}class BikeUI: public CompoundUserInfo<Bike>
{
private:
        BindedElement<int> year; 
        BindedElement<bool> lights; 
        BindedElement<string> manufacturer; 
public:
        BikeUI()
                :CompoundUserInfo<Bike>("bike"),
                year( this, "year", 0 ),
                lights( this, "electric lights", false ), 
                manufacturer( this, "manufacturer", "unknown")
        {
        }

        ...
}
\end{verbatim}
\end{Code}

 

\subsection{Member Function Documentation}
\hypertarget{classUserInfo_0f090c6525a3e8fb11634a553f467ede}{
\index{CompoundUserInfo@{CompoundUserInfo}!Assembly@{Assembly}}
\index{Assembly@{Assembly}!CompoundUserInfo@{CompoundUserInfo}}
\subsubsection[Assembly]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ static T$\ast$ UserInfo::Assembly (DOMElement \& {\em element}, \/  const string {\em tagName})\hspace{0.3cm}{\tt  \mbox{[}inline, static, inherited\mbox{]}}}}
\label{classUserInfo_0f090c6525a3e8fb11634a553f467ede}


This methods tries to assembly a new instance of type T (or some of its descendant types) according to a data stored in a DOMNode named tagName within a child nodes of the passed element. If an error occurs, it returns a NULL pointer. 

References Attribute::Get(), and Attribute::type.\hypertarget{classUserInfo_1d402661b82feccb5265a70f65c242e1}{
\index{CompoundUserInfo@{CompoundUserInfo}!Disassembly@{Disassembly}}
\index{Disassembly@{Disassembly}!CompoundUserInfo@{CompoundUserInfo}}
\subsubsection[Disassembly]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ static bool UserInfo::Disassembly (T \& {\em instance}, \/  DOMElement \& {\em element}, \/  const string {\em tagName}, \/  const string {\em help})\hspace{0.3cm}{\tt  \mbox{[}inline, static, inherited\mbox{]}}}}
\label{classUserInfo_1d402661b82feccb5265a70f65c242e1}


This methods tries to disassembly an instance of type T (or some of its descendant types) and build DOM tree accordingly. Then, it creates a new DOMNode named according tagName and connecti it to the passed DOMElement as a new child node (with a help attribute filled). 

References Attribute::help, Attribute::Set(), and Attribute::type.

Referenced by UserInfo::Disassembly(), and CompoundUserInfo$<$ T $>$::BindedElement$<$ U $>$::DisassemblyComponentsToXML().\hypertarget{classUserInfo_917b2257abc31b94c89ef3cd270e4a42}{
\index{CompoundUserInfo@{CompoundUserInfo}!Disassembly@{Disassembly}}
\index{Disassembly@{Disassembly}!CompoundUserInfo@{CompoundUserInfo}}
\subsubsection[Disassembly]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ static bool UserInfo::Disassembly (T \& {\em instance}, \/  DOMElement \& {\em element}, \/  const string {\em tagName})\hspace{0.3cm}{\tt  \mbox{[}inline, static, inherited\mbox{]}}}}
\label{classUserInfo_917b2257abc31b94c89ef3cd270e4a42}


This methods tries to disassembly an instance of type T (or some of its descendant types) and build DOM tree accordingly. Then, it creates a new DOMNode named according tagName and connecti it to the passed DOMElement as a new child node. 

References UserInfo::Disassembly().

\subsection{Member Data Documentation}
\hypertarget{classTypedUserInfo_c7ad10a9ff002383518155c965ade85c}{
\index{CompoundUserInfo@{CompoundUserInfo}!instance@{instance}}
\index{instance@{instance}!CompoundUserInfo@{CompoundUserInfo}}
\subsubsection[instance]{\setlength{\rightskip}{0pt plus 5cm}template$<$typename T$>$ const {\bf TypedUserInfo}$<$T$>$\& {\bf TypedUserInfo}$<$ T $>$::{\bf instance}\hspace{0.3cm}{\tt  \mbox{[}static, protected, inherited\mbox{]}}}}
\label{classTypedUserInfo_c7ad10a9ff002383518155c965ade85c}


the only instance of this class (each type T has its own instance) which is used as a factory for processing related userinfos 

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