\section{marlin\-:\-:Processor Class Reference}
\label{classmarlin_1_1Processor}\index{marlin\-::\-Processor@{marlin\-::\-Processor}}


Base class for Marlin processors.  




{\ttfamily \#include $<$Processor.\-h$>$}

Inheritance diagram for marlin\-:\-:Processor\-:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=9.000000cm]{classmarlin_1_1Processor}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item 
{\bf Processor} (const std\-::string \&type\-Name)
\begin{DoxyCompactList}\small\item\em Possible verbosity levels. \end{DoxyCompactList}\item 
virtual {\bf $\sim$\-Processor} ()\label{classmarlin_1_1Processor_a971ba8a4ccf1d63a1ddc797b649f3c65}

\begin{DoxyCompactList}\small\item\em Destructor. \end{DoxyCompactList}\item 
virtual {\bf Processor} $\ast$ {\bf new\-Processor} ()=0
\begin{DoxyCompactList}\small\item\em Return a new instance of the processor. \end{DoxyCompactList}\item 
virtual void {\bf init} ()
\begin{DoxyCompactList}\small\item\em Called at the begin of the job before anything is read. \end{DoxyCompactList}\item 
virtual void {\bf process\-Run\-Header} (L\-C\-Run\-Header $\ast$)
\begin{DoxyCompactList}\small\item\em Called for every run, e.\-g. \end{DoxyCompactList}\item 
virtual void {\bf process\-Event} (L\-C\-Event $\ast$)\label{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022}

\begin{DoxyCompactList}\small\item\em Called for every event -\/ the working horse. \end{DoxyCompactList}\item 
virtual void {\bf check} (L\-C\-Event $\ast$)
\begin{DoxyCompactList}\small\item\em Called for every event -\/ right after \doxyref{process\-Event()}{p.}{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022} has been called for this processor. \end{DoxyCompactList}\item 
virtual void {\bf end} ()\label{classmarlin_1_1Processor_a40c4bc6d5b67906954392c5bb1df28c1}

\begin{DoxyCompactList}\small\item\em Called after data processing for clean up in the inverse order of the \doxyref{init()}{p.}{classmarlin_1_1Processor_a8194fb92a428de40ea9d891c8c8aed6b} method so that resources allocated in the first processor also will be available for all following processors. \end{DoxyCompactList}\item 
virtual const std\-::string \& {\bf type} () const \label{classmarlin_1_1Processor_a4d8f741665d13b0ae54fda46defa5fe2}

\begin{DoxyCompactList}\small\item\em Return type name for the processor (as set in constructor). \end{DoxyCompactList}\item 
virtual const std\-::string \& {\bf name} () const \label{classmarlin_1_1Processor_a6df2065038d4139d58ccb06502f13538}

\begin{DoxyCompactList}\small\item\em Return name of this processor. \end{DoxyCompactList}\item 
virtual const std\-::string \& {\bf log\-Level\-Name} () const \label{classmarlin_1_1Processor_a906861ed8f974fa9ae9baf6c648a5f4c}

\begin{DoxyCompactList}\small\item\em Return name of the local verbosity level of this processor -\/ \char`\"{}\char`\"{} if not set. \end{DoxyCompactList}\item 
virtual {\bf String\-Parameters} $\ast$ {\bf parameters} ()\label{classmarlin_1_1Processor_abc658f97e62d200084800ae2f19ac4cb}

\begin{DoxyCompactList}\small\item\em Return parameters defined for this \doxyref{Processor}{p.}{classmarlin_1_1Processor}. \end{DoxyCompactList}\item 
virtual void {\bf print\-Description} ()\label{classmarlin_1_1Processor_a6b17cf6290819a52624a47d67b77e529}

\begin{DoxyCompactList}\small\item\em Print information about this processor in A\-S\-C\-I\-I steering file format. \end{DoxyCompactList}\item 
virtual void {\bf print\-Description\-X\-M\-L} (std\-::ostream \&stream=std\-::cout)\label{classmarlin_1_1Processor_a975c1bd3a1f6454c4fb91278a273cdce}

\begin{DoxyCompactList}\small\item\em Print information about this processor in X\-M\-L steering file format. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\void {\bf print\-Parameters} ()\label{classmarlin_1_1Processor_a831663d943767ea8bb459dcea815be3a}

\begin{DoxyCompactList}\small\item\em Print the parameters and their values depending on the given verbosity level. \end{DoxyCompactList}\item 
void {\bf print\-Parameters} ()\label{classmarlin_1_1Processor_a5b34ade8958b46bd31b44376ca3e3bcc}

\begin{DoxyCompactList}\small\item\em Print the parameters and their values with verbosity level M\-E\-S\-S\-A\-G\-E. \end{DoxyCompactList}\item 
const std\-::string \& {\bf description} ()\label{classmarlin_1_1Processor_aabc4d980662962d3545f7a78d8c1ab87}

\begin{DoxyCompactList}\small\item\em Description of processor. \end{DoxyCompactList}\item 
bool {\bf is\-First\-Event} ()
\begin{DoxyCompactList}\small\item\em True if first event in process\-Event(evt) -\/ use this e.\-g. \end{DoxyCompactList}\item 
std\-::string {\bf get\-L\-C\-I\-O\-In\-Type} (const std\-::string \&col\-Name)\label{classmarlin_1_1Processor_afa0757a0fad2a4c65ec8cef2cf31af39}

\begin{DoxyCompactList}\small\item\em Return the L\-C\-I\-O input type for the collection col\-Name -\/ empty string if col\-Name is not a registered collection name. \end{DoxyCompactList}\item 
std\-::string {\bf get\-L\-C\-I\-O\-Out\-Type} (const std\-::string \&col\-Name)\label{classmarlin_1_1Processor_aae8e8a3b6b0c55df2a6cdb8b0c933eef}

\begin{DoxyCompactList}\small\item\em Return the L\-C\-I\-O output type for the collection col\-Name -\/ empty string if col\-Name is not a registered collection name. \end{DoxyCompactList}\item 
bool {\bf is\-Input\-Collection\-Name} (const std\-::string \&parameter\-Name)
\begin{DoxyCompactList}\small\item\em True if the given parameter defines an L\-C\-I\-O input collection, i.\-e. \end{DoxyCompactList}\item 
bool {\bf is\-Output\-Collection\-Name} (const std\-::string \&parameter\-Name)\label{classmarlin_1_1Processor_a28c9455c55ac36f5fe8010e269180b10}

\begin{DoxyCompactList}\small\item\em True if the given parameter defines an L\-C\-I\-O output collection. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Protected Member Functions}
\begin{DoxyCompactItemize}
\item 
void {\bf set\-Return\-Value} (bool val)
\begin{DoxyCompactList}\small\item\em Helper function returns the \doxyref{Processor\-Parameter}{p.}{classmarlin_1_1ProcessorParameter} for the given name. \end{DoxyCompactList}\item 
void {\bf set\-Return\-Value} (const std\-::string \&{\bf name}, bool val)\label{classmarlin_1_1Processor_ae678bb70d20e0bb9503b23c1391d7b44}

\begin{DoxyCompactList}\small\item\em Set a named return value for this processor -\/ typically at end of \doxyref{process\-Event()}{p.}{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022} The value can be used in a condition in the steering file referred to by Processor\-Name.\-name of the processor. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\void {\bf register\-Processor\-Parameter} (const std\-::string \&{\bf name}, const std\-::string \&{\bf description}, T \&parameter, const T \&default\-Val, int set\-Size=0)
\begin{DoxyCompactList}\small\item\em Register a steering variable for this processor -\/ call in constructor of processor. \end{DoxyCompactList}\item 
void {\bf register\-Input\-Collection} (const std\-::string \&{\bf type}, const std\-::string \&{\bf name}, const std\-::string \&{\bf description}, std\-::string \&parameter, const std\-::string \&default\-Val, int set\-Size=0)\label{classmarlin_1_1Processor_a60e489b83117049d67ada1d0b2558199}

\begin{DoxyCompactList}\small\item\em Specialization of \doxyref{register\-Processor\-Parameter()}{p.}{classmarlin_1_1Processor_a0108fd7a5ab53996b0a8079dbbfd29d2} for a parameter that defines an input collection -\/ can be used fo checking the consistency of the steering file. \end{DoxyCompactList}\item 
void {\bf register\-Output\-Collection} (const std\-::string \&{\bf type}, const std\-::string \&{\bf name}, const std\-::string \&{\bf description}, std\-::string \&parameter, const std\-::string \&default\-Val, int set\-Size=0)\label{classmarlin_1_1Processor_a9dd7ac87ed50f09a973bb6e9c5e25316}

\begin{DoxyCompactList}\small\item\em Specialization of \doxyref{register\-Processor\-Parameter()}{p.}{classmarlin_1_1Processor_a0108fd7a5ab53996b0a8079dbbfd29d2} for a parameter that defines an output collection -\/ can be used fo checking the consistency of the steering file. \end{DoxyCompactList}\item 
void {\bf register\-Input\-Collections} (const std\-::string \&{\bf type}, const std\-::string \&{\bf name}, const std\-::string \&{\bf description}, String\-Vec \&parameter, const String\-Vec \&default\-Val, int set\-Size=0)\label{classmarlin_1_1Processor_a99289c938dc9d53f41399d79fa1e58b0}

\begin{DoxyCompactList}\small\item\em Specialization of \doxyref{register\-Processor\-Parameter()}{p.}{classmarlin_1_1Processor_a0108fd7a5ab53996b0a8079dbbfd29d2} for a parameter that defines one or several input collections -\/ can be used fo checking the consistency of the steering file. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\void {\bf register\-Optional\-Parameter} (const std\-::string \&{\bf name}, const std\-::string \&{\bf description}, T \&parameter, const T \&default\-Val, int set\-Size=0)
\begin{DoxyCompactList}\small\item\em Same as register\-Processor\-Parameter except that the parameter is optional. \end{DoxyCompactList}\item 
bool {\bf parameter\-Set} (const std\-::string \&{\bf name})\label{classmarlin_1_1Processor_ae0d7d4dddffb9cad699e1609818ca33f}

\begin{DoxyCompactList}\small\item\em Tests whether the parameter has been set in the steering file. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\void {\bf message} (const std\-::string \&message) const 
\begin{DoxyCompactList}\small\item\em Print message according to verbosity level of the templated parameter (one of D\-E\-B\-U\-G, M\-E\-S\-S\-A\-G\-E, W\-A\-R\-N\-I\-N\-G, E\-R\-R\-O\-R ) and the global parameter \char`\"{}\-Verbosity\char`\"{}. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\void {\bf message} (const std\-::basic\-\_\-ostream$<$ char, std\-::char\-\_\-traits$<$ char $>$ $>$ \&m) const 
\begin{DoxyCompactList}\small\item\em Same as message(const std\-::string\& message) except that it allows the output of more complex messages in the argument using the \doxyref{log()}{p.}{classmarlin_1_1Processor_a89cb8f8916ab54e4d572d884e717a870} method, e.\-g. \end{DoxyCompactList}\item 
std\-::stringstream \& {\bf log} () const 
\begin{DoxyCompactList}\small\item\em Returns an empty stringstream that is used by the message method. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Protected Attributes}
\begin{DoxyCompactItemize}
\item 
std\-::string {\bf \-\_\-description}
\begin{DoxyCompactList}\small\item\em Describes what the processor does. \end{DoxyCompactList}\item 
std\-::string {\bfseries \-\_\-type\-Name}\label{classmarlin_1_1Processor_aff5084639628a3a03965bb6447f5a3b9}

\item 
std\-::string {\bfseries \-\_\-processor\-Name}\label{classmarlin_1_1Processor_aa9c918e6bcc52fa366e222e39b0d236e}

\item 
{\bf String\-Parameters} $\ast$ {\bfseries \-\_\-parameters}\label{classmarlin_1_1Processor_aa093b0039fdf2591e1fe05170d416d9e}

\item 
Proc\-Param\-Map {\bfseries \-\_\-map}\label{classmarlin_1_1Processor_ad5cbe88ada12e56c0edcbfcde3d3b0ec}

\item 
bool {\bfseries \-\_\-is\-First\-Event}\label{classmarlin_1_1Processor_a843a9cacfcf06a0a84c054259a80a29c}

\item 
L\-C\-I\-O\-Type\-Map {\bfseries \-\_\-in\-Type\-Map}\label{classmarlin_1_1Processor_acf9be1e0ac4c66cf406224de2405e708}

\item 
L\-C\-I\-O\-Type\-Map {\bfseries \-\_\-out\-Type\-Map}\label{classmarlin_1_1Processor_a41675558c54a9cc5e4a7fa97801b6318}

\item 
std\-::string {\bfseries \-\_\-log\-Level\-Name}\label{classmarlin_1_1Processor_a84c2ba2bfd62a1dded6a1063d8dbdaf1}

\end{DoxyCompactItemize}
\subsection*{Friends}
\begin{DoxyCompactItemize}
\item 
class {\bfseries Processor\-Mgr}\label{classmarlin_1_1Processor_a08ac5ce1a2d3bbeeb9dd17fcd3c8ce71}

\item 
class {\bfseries C\-M\-Processor}\label{classmarlin_1_1Processor_a3df8d1864bb738248af93491cf49eda0}

\item 
class {\bfseries X\-M\-L\-Fix\-Coll\-Types}\label{classmarlin_1_1Processor_adeaf96e548686c45f75f82254be0b983}

\end{DoxyCompactItemize}


\subsection{Detailed Description}
Base class for Marlin processors. 

Users can optionaly overwrite the following methods\-: \par
 init, process\-Run, process\-Event and end.\par
 Use register\-Processor\-Parameter to define all parameters that the module uses. Registered parameters are filled automatically before \doxyref{init()}{p.}{classmarlin_1_1Processor_a8194fb92a428de40ea9d891c8c8aed6b} is called. With My\-Aplication -\/l you can print a list of available processors including the steering parameters they use/need.\par
 With My\-Aplication -\/x you can print an example X\-M\-L steering file for all known processors.

\begin{DoxySeeAlso}{See Also}
\doxyref{init}{p.}{classmarlin_1_1Processor_a8194fb92a428de40ea9d891c8c8aed6b} 

process\-Run 

\doxyref{process\-Event}{p.}{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022} 

\doxyref{end}{p.}{classmarlin_1_1Processor_a40c4bc6d5b67906954392c5bb1df28c1}
\end{DoxySeeAlso}
\begin{DoxyAuthor}{Author}
F. Gaede, D\-E\-S\-Y 
\end{DoxyAuthor}
\begin{DoxyVersion}{Version}

\end{DoxyVersion}
\begin{DoxyParagraph}{Id\-:}
\doxyref{Processor.\-h}{p.}{Processor_8h_source},v 1.\-38 2008-\/06-\/26 10\-:25\-:36 gaede Exp 
\end{DoxyParagraph}


\subsection{Constructor \& Destructor Documentation}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!Processor@{Processor}}
\index{Processor@{Processor}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{Processor}]{\setlength{\rightskip}{0pt plus 5cm}marlin\-::\-Processor\-::\-Processor (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{type\-Name}
\end{DoxyParamCaption}
)}\label{classmarlin_1_1Processor_a64c6a13ca7131ad05b016b2185f3dea0}


Possible verbosity levels. 

\doxyref{Global}{p.}{classmarlin_1_1Global} variable used to set the verbosity level Default constructor -\/ subclasses need to call this in their default constructor. 

References marlin\-::\-Processor\-Mgr\-::instance(), register\-Optional\-Parameter(), and marlin\-::\-Processor\-Mgr\-::register\-Processor().



\subsection{Member Function Documentation}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!check@{check}}
\index{check@{check}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{check}]{\setlength{\rightskip}{0pt plus 5cm}virtual void marlin\-::\-Processor\-::check (
\begin{DoxyParamCaption}
\item[{L\-C\-Event $\ast$}]{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [virtual]}}\label{classmarlin_1_1Processor_a23181ebcd9b4bb549b77710eb8a5f080}


Called for every event -\/ right after \doxyref{process\-Event()}{p.}{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022} has been called for this processor. 

Use to check processing and/or produce check plots. 

Reimplemented in {\bf marlin\-::\-Simple\-Fast\-M\-C\-Processor} \doxyref{}{p.}{classmarlin_1_1SimpleFastMCProcessor_ad995c551231263c63cb202ad61950cdd}, {\bf marlin\-::\-A\-I\-D\-A\-Processor} \doxyref{}{p.}{classmarlin_1_1AIDAProcessor_a8e150796de147ee8d55aa5151f499bd5}, {\bf Event\-Selector} \doxyref{}{p.}{classEventSelector_a450344495aa2a999f194f6e7526c13aa}, {\bf marlin\-::\-Test\-Processor} \doxyref{}{p.}{classmarlin_1_1TestProcessor_a83d4a79442de2deef8185fb0231e8d67}, and {\bf Statusmonitor} \doxyref{}{p.}{classStatusmonitor_a742a966f6df39d61a32be9b59c3eadf7}.

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!init@{init}}
\index{init@{init}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{init}]{\setlength{\rightskip}{0pt plus 5cm}virtual void marlin\-::\-Processor\-::init (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [virtual]}}\label{classmarlin_1_1Processor_a8194fb92a428de40ea9d891c8c8aed6b}


Called at the begin of the job before anything is read. 

Use to initialize the processor, e.\-g. book histograms. 

Reimplemented in {\bf marlin\-::\-Simple\-Fast\-M\-C\-Processor} \doxyref{}{p.}{classmarlin_1_1SimpleFastMCProcessor_aea0d8a3a1bde4211398554449ba61e34}, {\bf marlin\-::\-Conditions\-Processor} \doxyref{}{p.}{classmarlin_1_1ConditionsProcessor_a59a9c9ae25df88a4ebc29fae75c208ff}, {\bf marlin\-::\-L\-C\-I\-O\-Output\-Processor} \doxyref{}{p.}{classmarlin_1_1LCIOOutputProcessor_a23c540ec3d9be10fc4e4b5431bfe64e4}, {\bf marlin\-::\-A\-I\-D\-A\-Processor} \doxyref{}{p.}{classmarlin_1_1AIDAProcessor_a353d038e70349307dd78b8cd6a6e2a35}, {\bf marlin\-::\-Std\-Hep\-Reader} \doxyref{}{p.}{classmarlin_1_1StdHepReader_a440b12faf24a85d1ce0c7f0fe9f39217}, {\bf Event\-Selector} \doxyref{}{p.}{classEventSelector_a85f57085ea8afc77183e133f9a9538c4}, {\bf marlin\-::\-Test\-Processor} \doxyref{}{p.}{classmarlin_1_1TestProcessor_a642eda7da954ecd815df99f25a1c946b}, and {\bf Statusmonitor} \doxyref{}{p.}{classStatusmonitor_aab4918baa8a977b050bd3c968059ba3b}.

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!is\-First\-Event@{is\-First\-Event}}
\index{is\-First\-Event@{is\-First\-Event}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{is\-First\-Event}]{\setlength{\rightskip}{0pt plus 5cm}bool marlin\-::\-Processor\-::is\-First\-Event (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}}\label{classmarlin_1_1Processor_a1c6e4c09fb488c1be92bb4ac1a43fe86}


True if first event in process\-Event(evt) -\/ use this e.\-g. 

to initialize histograms etc. 

Referenced by marlin\-::\-Simple\-Fast\-M\-C\-Processor\-::check(), and marlin\-::\-Test\-Processor\-::process\-Event().

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!is\-Input\-Collection\-Name@{is\-Input\-Collection\-Name}}
\index{is\-Input\-Collection\-Name@{is\-Input\-Collection\-Name}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{is\-Input\-Collection\-Name}]{\setlength{\rightskip}{0pt plus 5cm}bool marlin\-::\-Processor\-::is\-Input\-Collection\-Name (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{parameter\-Name}
\end{DoxyParamCaption}
)}\label{classmarlin_1_1Processor_ae833b469ec413f3f781358a6b8474920}


True if the given parameter defines an L\-C\-I\-O input collection, i.\-e. 

the type has been defined with set\-L\-C\-I\-O\-In\-Type(). 

Referenced by get\-L\-C\-I\-O\-In\-Type(), marlin\-::\-X\-M\-L\-Fix\-Coll\-Types\-::parse(), and print\-Description\-X\-M\-L().

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!log@{log}}
\index{log@{log}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{log}]{\setlength{\rightskip}{0pt plus 5cm}std\-::stringstream \& marlin\-::\-Processor\-::log (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [protected]}}\label{classmarlin_1_1Processor_a89cb8f8916ab54e4d572d884e717a870}


Returns an empty stringstream that is used by the message method. 

\begin{DoxyRefDesc}{Deprecated}
\item[{\bf Deprecated}]\end{DoxyRefDesc}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!message@{message}}
\index{message@{message}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{message}]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T $>$ void marlin\-::\-Processor\-::message (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{message}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [protected]}}\label{classmarlin_1_1Processor_a8d99826f3489b21640d8606243c964a7}


Print message according to verbosity level of the templated parameter (one of D\-E\-B\-U\-G, M\-E\-S\-S\-A\-G\-E, W\-A\-R\-N\-I\-N\-G, E\-R\-R\-O\-R ) and the global parameter \char`\"{}\-Verbosity\char`\"{}. 

If Marlin is compiled w/o debug mode (\$\-M\-A\-R\-L\-I\-N\-D\-E\-B\-U\-G not set) then D\-E\-B\-U\-G messages will be ignored completely at compile time, i.\-e. no output (and code!) will be generated, regardless of the value of the \char`\"{}\-Verbosity\char`\"{} parameter. This is useful in order to save C\-P\-U time in production mode.\par
 Every line of the output string will be prepended by the verbosity level of the message and the processor name, e.\-g\-: 
\begin{DoxyPre}
  [ MESSAGE "MyTestProcessor" ]  processing event 42 in run 4711
\end{DoxyPre}
 Use this method for simple strings. In order to use more complex messages, including numbers, use\-: \begin{DoxySeeAlso}{See Also}
void message( const std\-::basic\-\_\-ostream$<$char, std\-::char\-\_\-traits$<$char$>$ $>$\& m) 
\end{DoxySeeAlso}
\begin{DoxyRefDesc}{Deprecated}
\item[{\bf Deprecated}]\end{DoxyRefDesc}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!message@{message}}
\index{message@{message}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{message}]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T $>$ void marlin\-::\-Processor\-::message (
\begin{DoxyParamCaption}
\item[{const std\-::basic\-\_\-ostream$<$ char, std\-::char\-\_\-traits$<$ char $>$ $>$ \&}]{m}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [protected]}}\label{classmarlin_1_1Processor_a3e9e50c78fb102cad4fe905e96558b17}


Same as message(const std\-::string\& message) except that it allows the output of more complex messages in the argument using the \doxyref{log()}{p.}{classmarlin_1_1Processor_a89cb8f8916ab54e4d572d884e717a870} method, e.\-g. 

\-: 
\begin{DoxyPre}
message<MESSAGE>( \doxyref{log()}{p.}{classmarlin_1_1Processor_a89cb8f8916ab54e4d572d884e717a870} 
                  << " processing event " << evt->getEventNumber() 
                  << "  in run "          << evt->getRunNumber() 
                  ) ;
\end{DoxyPre}


\begin{DoxyRefDesc}{Deprecated}
\item[{\bf Deprecated}]\begin{DoxySeeAlso}{See Also}
void message(  const std\-::string\& message ) 

std\-::stringstream\& \doxyref{log()}{p.}{classmarlin_1_1Processor_a89cb8f8916ab54e4d572d884e717a870} 
\end{DoxySeeAlso}
\end{DoxyRefDesc}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!new\-Processor@{new\-Processor}}
\index{new\-Processor@{new\-Processor}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{new\-Processor}]{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf Processor}$\ast$ marlin\-::\-Processor\-::new\-Processor (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [pure virtual]}}\label{classmarlin_1_1Processor_a75ba6b66644e5273a896053df31aac4d}


Return a new instance of the processor. 

Has to be implemented by subclasses. 

Implemented in {\bf marlin\-::\-Simple\-Fast\-M\-C\-Processor} \doxyref{}{p.}{classmarlin_1_1SimpleFastMCProcessor_a2bbffb6fdd7220f46f3af6c1f487259b}, {\bf marlin\-::\-L\-C\-I\-O\-Output\-Processor} \doxyref{}{p.}{classmarlin_1_1LCIOOutputProcessor_a6caa14489b13c7e0efa4b720ace3823e}, {\bf marlin\-::\-Conditions\-Processor} \doxyref{}{p.}{classmarlin_1_1ConditionsProcessor_a98be5866f79a17930450f1ab456e7495}, {\bf marlin\-::\-A\-I\-D\-A\-Processor} \doxyref{}{p.}{classmarlin_1_1AIDAProcessor_a75a426e4f456d50512b5bd8a7ea679ba}, {\bf marlin\-::\-Std\-Hep\-Reader} \doxyref{}{p.}{classmarlin_1_1StdHepReader_a455be55c661163301b8d1b5606e9b4a7}, {\bf Event\-Selector} \doxyref{}{p.}{classEventSelector_ad4cf868bec22a0fce212db930e2bb1dd}, {\bf marlin\-::\-Test\-Processor} \doxyref{}{p.}{classmarlin_1_1TestProcessor_a83442912569e02d8c9f089ce4d57ab24}, and {\bf Statusmonitor} \doxyref{}{p.}{classStatusmonitor_a20e30f618bd3521e5fc8bf93ee005469}.



Referenced by marlin\-::\-Processor\-Mgr\-::add\-Active\-Processor().

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!process\-Run\-Header@{process\-Run\-Header}}
\index{process\-Run\-Header@{process\-Run\-Header}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{process\-Run\-Header}]{\setlength{\rightskip}{0pt plus 5cm}virtual void marlin\-::\-Processor\-::process\-Run\-Header (
\begin{DoxyParamCaption}
\item[{L\-C\-Run\-Header $\ast$}]{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [virtual]}}\label{classmarlin_1_1Processor_a8e9e4ad0dd66df602e6025a5adb0b433}


Called for every run, e.\-g. 

overwrite to initialize run dependent histograms. 

Reimplemented in {\bf marlin\-::\-Simple\-Fast\-M\-C\-Processor} \doxyref{}{p.}{classmarlin_1_1SimpleFastMCProcessor_ad0ff8519d0da1edb7e26017292c0260e}, {\bf marlin\-::\-L\-C\-I\-O\-Output\-Processor} \doxyref{}{p.}{classmarlin_1_1LCIOOutputProcessor_af128e9379a08ca77cd776bf6e6865dda}, {\bf marlin\-::\-A\-I\-D\-A\-Processor} \doxyref{}{p.}{classmarlin_1_1AIDAProcessor_a6fba6814c0f1af5dd7650e035cdc6fc8}, {\bf Event\-Selector} \doxyref{}{p.}{classEventSelector_a957277961f59d3f35c3d8ba18e3b5ece}, {\bf marlin\-::\-Test\-Processor} \doxyref{}{p.}{classmarlin_1_1TestProcessor_ad472da387b0d41f925685473527b6dda}, and {\bf Statusmonitor} \doxyref{}{p.}{classStatusmonitor_aaf8f7b324717df007351671a58d5b8cf}.

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!register\-Optional\-Parameter@{register\-Optional\-Parameter}}
\index{register\-Optional\-Parameter@{register\-Optional\-Parameter}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{register\-Optional\-Parameter}]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T $>$ void marlin\-::\-Processor\-::register\-Optional\-Parameter (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{name, }
\item[{const std\-::string \&}]{description, }
\item[{T \&}]{parameter, }
\item[{const T \&}]{default\-Val, }
\item[{int}]{set\-Size = {\ttfamily 0}}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [protected]}}\label{classmarlin_1_1Processor_a35aee941a8dabe34a4a066f9aee43193}


Same as register\-Processor\-Parameter except that the parameter is optional. 

The value of the parameter will still be set to the default value, which is used to print an example steering line. Use \doxyref{parameter\-Set()}{p.}{classmarlin_1_1Processor_ae0d7d4dddffb9cad699e1609818ca33f} to check whether it actually has been set in the steering file. 

Referenced by Processor().

\index{marlin\-::\-Processor@{marlin\-::\-Processor}!register\-Processor\-Parameter@{register\-Processor\-Parameter}}
\index{register\-Processor\-Parameter@{register\-Processor\-Parameter}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{register\-Processor\-Parameter}]{\setlength{\rightskip}{0pt plus 5cm}template$<$class T $>$ void marlin\-::\-Processor\-::register\-Processor\-Parameter (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{name, }
\item[{const std\-::string \&}]{description, }
\item[{T \&}]{parameter, }
\item[{const T \&}]{default\-Val, }
\item[{int}]{set\-Size = {\ttfamily 0}}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}, {\ttfamily [protected]}}\label{classmarlin_1_1Processor_a0108fd7a5ab53996b0a8079dbbfd29d2}


Register a steering variable for this processor -\/ call in constructor of processor. 

The default value has to be of the {\itshape same} type as the parameter, e.\-g.\par
 float \-\_\-cut ;\par
 ...\par
 register\-Processor\-Parameter( \char`\"{}\-Cut\char`\"{}, \char`\"{}cut...\char`\"{}, \-\_\-cut , float( 3.\-141592 ) ) ;\par
 as implicit conversions don't work for templates.\par
 The optional parameter set\-Size is used for formating the printout of parameters. This can be used if the parameter values are expected to come in sets of fixed size. \index{marlin\-::\-Processor@{marlin\-::\-Processor}!set\-Return\-Value@{set\-Return\-Value}}
\index{set\-Return\-Value@{set\-Return\-Value}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{set\-Return\-Value}]{\setlength{\rightskip}{0pt plus 5cm}void marlin\-::\-Processor\-::set\-Return\-Value (
\begin{DoxyParamCaption}
\item[{bool}]{val}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [protected]}}\label{classmarlin_1_1Processor_a644998598d6b2faa2140a2cf2bb6fb5c}


Helper function returns the \doxyref{Processor\-Parameter}{p.}{classmarlin_1_1ProcessorParameter} for the given name. 

Set the return value for this processor -\/ typically at end of \doxyref{process\-Event()}{p.}{classmarlin_1_1Processor_a348ef28b0e6d486575610251e8831022}. The value can be used in a condition in the steering file referred to by the name of the processor. 

References marlin\-::\-Processor\-Mgr\-::instance(), and marlin\-::\-Processor\-Mgr\-::set\-Processor\-Return\-Value().



Referenced by marlin\-::\-Test\-Processor\-::process\-Event().



\subsection{Member Data Documentation}
\index{marlin\-::\-Processor@{marlin\-::\-Processor}!\-\_\-description@{\-\_\-description}}
\index{\-\_\-description@{\-\_\-description}!marlin::Processor@{marlin\-::\-Processor}}
\subsubsection[{\-\_\-description}]{\setlength{\rightskip}{0pt plus 5cm}std\-::string marlin\-::\-Processor\-::\-\_\-description\hspace{0.3cm}{\ttfamily [protected]}}\label{classmarlin_1_1Processor_ac69835884a0c89d19d80b0390e975072}


Describes what the processor does. 

Set in constructor. 

The documentation for this class was generated from the following files\-:\begin{DoxyCompactItemize}
\item 
Processor.\-h\item 
Processor.\-cc\end{DoxyCompactItemize}
