classstorage__manager_3_01pat_00_01vat_00_01alloc_00_01memory__storage_01_4.tex

这是一个用于数据挖掘的常用算法的模板库（数据挖掘的C++模板库for UNIX)

\section{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$ Class Template Reference}
\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4}\index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
Storage Manager class partially specialized to Memory-based Storage manager to stores VAT in Memory.  


{\tt \#include $<$mem\_\-storage\_\-manager.h$>$}

\subsection*{Public Types}
\begin{CompactItemize}
\item 
typedef HASHNS::hash\_\-map$<$ C\_\-ST, VAT $\ast$, HASHNS::hash$<$ C\_\-ST $>$, C\_\-CF, ALLOC$<$ pair$<$ const C\_\-ST, VAT $\ast$ $>$ $>$ $>$ \textbf{CC\_\-ST\_\-TO\_\-VATPTR}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_d17789689203f8479b8502eda66b2e77}

\item 
typedef CC\_\-ST\_\-TO\_\-VATPTR::const\_\-iterator \textbf{CONST\_\-IT}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_0c7e677f74d1894f192270ca6a3cbc79}

\item 
typedef CC\_\-ST\_\-TO\_\-VATPTR::iterator \textbf{IT}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_6726099d0c66a5600e0849cf66f2197d}

\item 
typedef \bf{pattern\_\-support}$<$ typename PAT::MINE\_\-PROPS $>$ \textbf{PAT\_\-SUP}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_771411d56b6a844cfb0c0a620b62618b}

\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
\textbf{storage\_\-manager} (\bf{pat\_\-fam}$<$ PAT $>$ \&freq\_\-one\_\-pats, vector$<$ VAT $\ast$ $>$ \&freq\_\-one\_\-vats)\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_2a80da96fd30322e280e4cc762350249}

\item 
bool \bf{find} (PAT $\ast$const \&p) const 
\item 
VAT $\ast$ \bf{get\_\-vat} (PAT $\ast$const \&p) const 
\item 
void \bf{delete\_\-vat} (PAT $\ast$const \&p)
\item 
bool \bf{add\_\-vat} (PAT $\ast$const \&p, VAT $\ast$v)
\item 
VAT $\ast$$\ast$ \bf{intersect} (PAT $\ast$const \&p1, PAT $\ast$const \&p2, \bf{PAT\_\-SUP} $\ast$$\ast$cand\_\-sups, PAT $\ast$$\ast$cand\_\-pats, bool is\_\-l2)
\item 
void \textbf{print} () const \label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_91a69acea82c668e1dd2bca36b085f6d}

\end{CompactItemize}


\subsection{Detailed Description}
\subsubsection*{template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ class storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}

Storage Manager class partially specialized to Memory-based Storage manager to stores VAT in Memory. 

An object store. Specifically we want to store VATs and their associated patterns. It provides routines to find/access/store VATs with a pattern key. 



\subsection{Member Function Documentation}
\index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}!add_vat@{add\_\-vat}}
\index{add_vat@{add\_\-vat}!storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ bool \bf{storage\_\-manager}$<$ PAT, VAT, ALLOC, \bf{memory\_\-storage} $>$::add\_\-vat (PAT $\ast$const \& {\em p}, VAT $\ast$ {\em v})\hspace{0.3cm}{\tt  [inline]}}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_e7256dba2f08982b8433613fd53e3bc3}


Map the pattern to the VAT. \index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}!delete_vat@{delete\_\-vat}}
\index{delete_vat@{delete\_\-vat}!storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ void \bf{storage\_\-manager}$<$ PAT, VAT, ALLOC, \bf{memory\_\-storage} $>$::delete\_\-vat (PAT $\ast$const \& {\em p})\hspace{0.3cm}{\tt  [inline]}}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_b60523c6fb8da71fa54c46c2d695392d}


Delete the vat. \index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}!find@{find}}
\index{find@{find}!storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ bool \bf{storage\_\-manager}$<$ PAT, VAT, ALLOC, \bf{memory\_\-storage} $>$::find (PAT $\ast$const \& {\em p}) const\hspace{0.3cm}{\tt  [inline]}}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_0f310c70843da125fd825b3cddfebcb9}


Return true if the pattern is found in the storage manager. \index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}!get_vat@{get\_\-vat}}
\index{get_vat@{get\_\-vat}!storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ VAT$\ast$ \bf{storage\_\-manager}$<$ PAT, VAT, ALLOC, \bf{memory\_\-storage} $>$::get\_\-vat (PAT $\ast$const \& {\em p}) const\hspace{0.3cm}{\tt  [inline]}}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_f1b81ff2505352a3b9d34733cfe51926}


Return the vat corresponding to the pattern. \index{storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}!intersect@{intersect}}
\index{intersect@{intersect}!storage_manager< PAT, VAT, ALLOC, memory_storage >@{storage\_\-manager$<$ PAT, VAT, ALLOC, memory\_\-storage $>$}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class PAT, template$<$ typename $>$ class ALLOC, class VAT$>$ VAT$\ast$$\ast$ \bf{storage\_\-manager}$<$ PAT, VAT, ALLOC, \bf{memory\_\-storage} $>$::intersect (PAT $\ast$const \& {\em p1}, PAT $\ast$const \& {\em p2}, \bf{PAT\_\-SUP} $\ast$$\ast$ {\em cand\_\-sups}, PAT $\ast$$\ast$ {\em cand\_\-pats}, bool {\em is\_\-l2})\hspace{0.3cm}{\tt  [inline]}}\label{classstorage__manager_3_01PAT_00_01VAT_00_01ALLOC_00_01memory__storage_01_4_6232a8d6f413103d5ca623a8ffae3091}


Generate candidate VATs for the next level, from the provided patterns. 

The documentation for this class was generated from the following file:\begin{CompactItemize}
\item 
mem\_\-storage\_\-manager.h\end{CompactItemize}