\hypertarget{map_8c}{
\section{map.c File Reference}
\label{map_8c}\index{map.c@{map.c}}
}
Provoides functionality concerned with creating and manipulating a LATC\_\-map. 

{\tt \#include \char`\"{}map\_\-p.h\char`\"{}}\par
{\tt \#include \char`\"{}error\_\-p.h\char`\"{}}\par
{\tt \#include \char`\"{}addr.h\char`\"{}}\par
{\tt \#include \char`\"{}number.ic\char`\"{}}\par
{\tt \#include \char`\"{}AG\_\-rim\-Type\_\-s.h\char`\"{}}\par
{\tt \#include $<$string.h$>$}\par


Include dependency graph for map.c:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=285pt]{map_8c__incl}
\end{center}
\end{figure}
\subsection*{Functions}
\begin{CompactItemize}
\item 
size\_\-t \hyperlink{map_8c_a0}{RIM\_\-sizeof\-Map} (void)
\begin{CompactList}\small\item\em Calculate the total size of a RIM\_\-map object. \item\end{CompactList}\item 
\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ \hyperlink{map_8c_a1}{RIM\_\-construct\-Map} (void $\ast$buf)
\begin{CompactList}\small\item\em Initialise the supplied memory as a RIM\_\-map object. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a2}{RIM\_\-set\-Bit} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Set a bit in the map. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a3}{RIM\_\-clear\-Bit} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Clear a bit in the map. \item\end{CompactList}\item 
int \hyperlink{map_8c_a4}{RIM\_\-count\-Bits} (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Clear a bit in the map. \item\end{CompactList}\item 
int \hyperlink{map_8c_a5}{RIM\_\-check\-Bit} (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Check a bit in the map. \item\end{CompactList}\item 
void \hyperlink{map_8c_a6}{RIM\_\-set\-ACD} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Set all the bits in the ARC and AFE submaps. \item\end{CompactList}\item 
void \hyperlink{map_8c_a7}{RIM\_\-clear\-ACD} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Clear all the bits in the ARC and AFE submaps. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a8}{RIM\_\-set\-TWR} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, unsigned twr)
\begin{CompactList}\small\item\em Set all the bits in TEM, TIC, CCC, CRC, CFE, TCC TRC and TFE submaps corresponding to a particular tower. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a9}{RIM\_\-clear\-TWR} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, unsigned twr)
\begin{CompactList}\small\item\em Clear all the bits in TEM, TIC, CCC, CRC, CFE, TCC TRC and TFE submaps corresponding to a particular tower. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a10}{RIM\_\-set\-By\-TWR} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, unsigned twr)
\item 
unsigned \hyperlink{map_8c_a11}{RIM\_\-clear\-By\-TWR} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, unsigned twr)
\item 
void \hyperlink{map_8c_a12}{RIM\_\-set\-Map} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Set the map. \item\end{CompactList}\item 
void \hyperlink{map_8c_a13}{RIM\_\-clear\-Map} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Clear the map. \item\end{CompactList}\item 
void \hyperlink{map_8c_a14}{RIM\_\-dump\-Map} (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, FILE $\ast$fp)
\begin{CompactList}\small\item\em Print out the map. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a15}{map\-Index} (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr, unsigned $\ast$index)
\begin{CompactList}\small\item\em Convert the address into an index appropriate for this type of map as well as performing various checks on the input parameters. \item\end{CompactList}\item 
unsigned \hyperlink{map_8c_a16}{map\-Range} (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$map, \hyperlink{lrd_8h_a0}{RIM\_\-type} type, unsigned twr, unsigned $\ast$start, unsigned $\ast$end)
\begin{CompactList}\small\item\em Find start and end indicies to use in a loop over all the bits in one tower (ie the first bit of the tower and the bit one past the last bit of the same tower). \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Provoides functionality concerned with creating and manipulating a LATC\_\-map. 

\begin{Desc}
\item[Author:]James Swain -- \href{mailto:jswain@slac.stanford.edu}{\tt jswain@slac.stanford.edu}\end{Desc}


\subsection{Function Documentation}
\hypertarget{map_8c_a15}{
\index{map.c@{map.c}!mapIndex@{mapIndex}}
\index{mapIndex@{mapIndex}!map.c@{map.c}}
\subsubsection[mapIndex]{\setlength{\rightskip}{0pt plus 5cm}unsigned map\-Index (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, unsigned $\ast$ {\em index})}}
\label{map_8c_a15}


Convert the address into an index appropriate for this type of map as well as performing various checks on the input parameters. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a map structure \item[{\em type}]Type of the map \item[{\em addr}]Pointer to an address structure identifying the required bit \item[{\em index}]Pointer to location to store the calculated index \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a16}{
\index{map.c@{map.c}!mapRange@{mapRange}}
\index{mapRange@{mapRange}!map.c@{map.c}}
\subsubsection[mapRange]{\setlength{\rightskip}{0pt plus 5cm}unsigned map\-Range (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em twr}, unsigned $\ast$ {\em start}, unsigned $\ast$ {\em end})}}
\label{map_8c_a16}


Find start and end indicies to use in a loop over all the bits in one tower (ie the first bit of the tower and the bit one past the last bit of the same tower). 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a map structure \item[{\em type}]Type of the map \item[{\em twr}]Tower ID \item[{\em start}]Pointer to location to store the index of the start bit \item[{\em end}]Pointer to location to store the index of the end bit \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a5}{
\index{map.c@{map.c}!RIM_checkBit@{RIM\_\-checkBit}}
\index{RIM_checkBit@{RIM\_\-checkBit}!map.c@{map.c}}
\subsubsection[RIM\_\-checkBit]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-check\-Bit (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{map_8c_a5}


Check a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated \item[{\em type}]Identifies map to manipulate \item[{\em addr}]bit to check \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em 0}]if the bit is clear \item[{\em 1}]if the bit is set\end{description}
\end{Desc}
\hypertarget{map_8c_a7}{
\index{map.c@{map.c}!RIM_clearACD@{RIM\_\-clearACD}}
\index{RIM_clearACD@{RIM\_\-clearACD}!map.c@{map.c}}
\subsubsection[RIM\_\-clearACD]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-clear\-ACD (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map})}}
\label{map_8c_a7}


Clear all the bits in the ARC and AFE submaps. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure\end{description}
\end{Desc}
\hypertarget{map_8c_a3}{
\index{map.c@{map.c}!RIM_clearBit@{RIM\_\-clearBit}}
\index{RIM_clearBit@{RIM\_\-clearBit}!map.c@{map.c}}
\subsubsection[RIM\_\-clearBit]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-clear\-Bit (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{map_8c_a3}


Clear a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated \item[{\em type}]Identifies map to manipulate \item[{\em addr}]bit to clear \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a11}{
\index{map.c@{map.c}!RIM_clearByTWR@{RIM\_\-clearByTWR}}
\index{RIM_clearByTWR@{RIM\_\-clearByTWR}!map.c@{map.c}}
\subsubsection[RIM\_\-clearByTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-clear\-By\-TWR (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em twr})}}
\label{map_8c_a11}


\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure \item[{\em type}]Identifies the sub-map to manipulate \item[{\em twr}]Index of a tower \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a13}{
\index{map.c@{map.c}!RIM_clearMap@{RIM\_\-clearMap}}
\index{RIM_clearMap@{RIM\_\-clearMap}!map.c@{map.c}}
\subsubsection[RIM\_\-clearMap]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-clear\-Map (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map})}}
\label{map_8c_a13}


Clear the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\end{description}
\end{Desc}
\hypertarget{map_8c_a9}{
\index{map.c@{map.c}!RIM_clearTWR@{RIM\_\-clearTWR}}
\index{RIM_clearTWR@{RIM\_\-clearTWR}!map.c@{map.c}}
\subsubsection[RIM\_\-clearTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-clear\-TWR (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, unsigned {\em twr})}}
\label{map_8c_a9}


Clear all the bits in TEM, TIC, CCC, CRC, CFE, TCC TRC and TFE submaps corresponding to a particular tower. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure \item[{\em twr}]Index of a tower \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-ADDR\_\-RANGE}]if the twr ID is out of range \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a1}{
\index{map.c@{map.c}!RIM_constructMap@{RIM\_\-constructMap}}
\index{RIM_constructMap@{RIM\_\-constructMap}!map.c@{map.c}}
\subsubsection[RIM\_\-constructMap]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{structRIM__map__}{RIM\_\-map}$\ast$ RIM\_\-construct\-Map (void $\ast$ {\em buf})}}
\label{map_8c_a1}


Initialise the supplied memory as a RIM\_\-map object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em buf}]Block of memory, at least as large as RIM\_\-sizeof\-Map, to initalise as a RIM\_\-map object \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Pointer to an initialise RIM\_\-map object\end{Desc}
\hypertarget{map_8c_a4}{
\index{map.c@{map.c}!RIM_countBits@{RIM\_\-countBits}}
\index{RIM_countBits@{RIM\_\-countBits}!map.c@{map.c}}
\subsubsection[RIM\_\-countBits]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-count\-Bits (const \hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type})}}
\label{map_8c_a4}


Clear a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated \item[{\em type}]Identifies map to count \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Number of bits set in the map, or -1 for an illegal type\end{Desc}
\hypertarget{map_8c_a14}{
\index{map.c@{map.c}!RIM_dumpMap@{RIM\_\-dumpMap}}
\index{RIM_dumpMap@{RIM\_\-dumpMap}!map.c@{map.c}}
\subsubsection[RIM\_\-dumpMap]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-dump\-Map (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, FILE $\ast$ {\em fp})}}
\label{map_8c_a14}


Print out the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fp}]Pointer to file to dump the map to \item[{\em map}]Pointer to an initialised map structure\end{description}
\end{Desc}
\hypertarget{map_8c_a6}{
\index{map.c@{map.c}!RIM_setACD@{RIM\_\-setACD}}
\index{RIM_setACD@{RIM\_\-setACD}!map.c@{map.c}}
\subsubsection[RIM\_\-setACD]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-set\-ACD (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map})}}
\label{map_8c_a6}


Set all the bits in the ARC and AFE submaps. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure\end{description}
\end{Desc}
\hypertarget{map_8c_a2}{
\index{map.c@{map.c}!RIM_setBit@{RIM\_\-setBit}}
\index{RIM_setBit@{RIM\_\-setBit}!map.c@{map.c}}
\subsubsection[RIM\_\-setBit]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set\-Bit (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{map_8c_a2}


Set a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated \item[{\em type}]Identifies map to manipulate \item[{\em addr}]bit to set \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a10}{
\index{map.c@{map.c}!RIM_setByTWR@{RIM\_\-setByTWR}}
\index{RIM_setByTWR@{RIM\_\-setByTWR}!map.c@{map.c}}
\subsubsection[RIM\_\-setByTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set\-By\-TWR (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{lrd_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em twr})}}
\label{map_8c_a10}


\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure \item[{\em type}]Identifies the sub-map to manipulate \item[{\em twr}]Index of a tower \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a12}{
\index{map.c@{map.c}!RIM_setMap@{RIM\_\-setMap}}
\index{RIM_setMap@{RIM\_\-setMap}!map.c@{map.c}}
\subsubsection[RIM\_\-setMap]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-set\-Map (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map})}}
\label{map_8c_a12}


Set the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure\end{description}
\end{Desc}
\hypertarget{map_8c_a8}{
\index{map.c@{map.c}!RIM_setTWR@{RIM\_\-setTWR}}
\index{RIM_setTWR@{RIM\_\-setTWR}!map.c@{map.c}}
\subsubsection[RIM\_\-setTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set\-TWR (\hyperlink{structRIM__map__}{RIM\_\-map} $\ast$ {\em map}, unsigned {\em twr})}}
\label{map_8c_a8}


Set all the bits in TEM, TIC, CCC, CRC, CFE, TCC TRC and TFE submaps corresponding to a particular tower. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure \item[{\em twr}]Index of a tower \end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-ADDR\_\-RANGE}]if the twr ID is out of range \item[{\em RIM\_\-SUCCESS}]if everything goes well\end{description}
\end{Desc}
\hypertarget{map_8c_a0}{
\index{map.c@{map.c}!RIM_sizeofMap@{RIM\_\-sizeofMap}}
\index{RIM_sizeofMap@{RIM\_\-sizeofMap}!map.c@{map.c}}
\subsubsection[RIM\_\-sizeofMap]{\setlength{\rightskip}{0pt plus 5cm}size\_\-t RIM\_\-sizeof\-Map (void)}}
\label{map_8c_a0}


Calculate the total size of a RIM\_\-map object. 

\begin{Desc}
\item[Returns:]Amount of memory required to accomodate a RIM\_\-map object\end{Desc}