//##### PART : DECLARATIONS #############################
//#######################################################

template <typename SYMBOL, typename WEIGHT>
class Cell;

template <typename SYMBOL, typename WEIGHT>
class Node;

template <typename SYMBOL, typename WEIGHT>
class InternalNode ;

template <typename SYMBOL, typename WEIGHT>
class TerminalNode ;

template <typename SYMBOL, typename WEIGHT, unsigned int ARY>
class BasicHuffmanTree;

template <typename SYMBOL, typename WEIGHT, unsigned int ARY = 2>
class LoadedHuffmanTree;

template <typename WEIGHT, unsigned int ARY = 2>
class DriedHuffmanTree;

template <typename SYMBOL, typename WEIGHT>
class lessNodesCompare;

template <typename SYMBOL, typename WEIGHT>
class lessNodesCorrectingCompare01;

template <typename SYMBOL, typename WEIGHT>
class lessNodesCorrectingCompare02;

template <typename SYMBOL, typename WEIGHT>
class lessCellsCompare;

template <typename T1>
class lessVectorsAlterCompare;



<a NAME="label_Cell_class"></a>
//#######################################################
//##### PART : template class <b><a href="#label_Cell_method">Cell</a></b> ######################
//############ <font color="FF00FF"><b>Definition</b></font> ###############################
//#######################################################

//----------- template class Cell -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class Cell
{
template &lt;typename S1, typename W1, unsigned int A1&gt; friend class BasicHuffmanTree;

friend class TerminalNode&lt;SYMBOL, WEIGHT&gt;;
friend class lessCellsCompare&lt;SYMBOL, WEIGHT&gt;;
friend istream& operator&gt;&gt; &lt;SYMBOL, WEIGHT&gt; (istream &str_o, Cell&lt;SYMBOL, WEIGHT&gt;& instance_i);

        private :
                SYMBOL  data_symbol_;
                WEIGHT  data_weight_;
                unsigned int    symbol_original_index_;
                vector&lt;CODE&gt;    symbol_path_;
        protected :

        public :
                Cell () {}
                Cell (
                        const SYMBOL&   data_symbol_i,
                        const WEIGHT&   data_weight_i,
                        unsigned int    symbol_original_index_i = UINT_MAX
                        );
                virtual ~Cell () {}

};



<a NAME="label_Node_class"></a>
//#######################################################
//##### PART : template class <b><a href="#label_Node_method">Node</a></b> ######################
//############ <font color="FF00FF"><b>Definition</b></font> ###############################
//#######################################################

//----------- template class Node -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class Node
{
template &lt;typename S1, typename W1, unsigned int A1&gt; friend class BasicHuffmanTree;

friend class InternalNode&lt;SYMBOL, WEIGHT&gt;;
friend class lessNodesCompare&lt;SYMBOL, WEIGHT&gt;;
friend class lessNodesCorrectingCompare01&lt;SYMBOL, WEIGHT&gt;;
friend class lessNodesCorrectingCompare02&lt;SYMBOL, WEIGHT&gt;;
friend ostream& operator&lt;&lt; &lt;SYMBOL, WEIGHT&gt; (ostream &str_o, const Node&lt;SYMBOL, WEIGHT&gt;& instance_i);

typedef map&lt;SYMBOL, WEIGHT, less&lt;SYMBOL&gt; &gt; Node_MAP_SYMBOLS;

        private :
        protected :
                Node_MAP_SYMBOLS        mapSymbols_;
                WEIGHT                  weight_;
                bool                    is_TerminalNode_;
                int                     absorbtion_stage_;
                int                     creation_stage_;

        public :
                Node () {weight_ = WEIGHT (); absorbtion_stage_ = -2; creation_stage_ = -1;}
                virtual ~Node () {}
};



<a NAME="label_InternalNode_class"></a>
//#######################################################
//##### PART : template class <b><a href="#label_InternalNode_method">InternalNode</a></b> ##############
//############ <font color="FF00FF"><b>Definition</b></font> ###############################
//#######################################################

//----------- template class InternalNode -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class InternalNode : public Node&lt;SYMBOL, WEIGHT&gt;
{
template &lt;typename S1, typename W1, unsigned int A1&gt; friend class BasicHuffmanTree;
        private :
                vector&lt;Node&ltSYMBOL, WEIGHT&gt;*&gt;   arc_;
        protected :
                void addNode (Node&lt;SYMBOL, WEIGHT&gt; const *  const ptr2_i);
        public :
                InternalNode () {is_TerminalNode_ = false;}
                ~InternalNode () {}
};



<a NAME="label_TerminalNode_class"></a>
//#######################################################
//##### PART : template class <b><a href="#label_TerminalNode_method">TerminalNode</a></b> ##############
//############ <font color="FF00FF"><b>Definition</b></font> ###############################
//#######################################################

//----------- template class TerminalNode -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class TerminalNode : public Node&lt;SYMBOL, WEIGHT&gt;
{
template &lt;typename S1, typename W1, unsigned int A1&gt; friend class BasicHuffmanTree;
        private :

        protected :
        public :
                TerminalNode () {is_TerminalNode_ = true;}
                TerminalNode (const Cell&lt;SYMBOL, WEIGHT&gt;& cell_i);
                ~TerminalNode () {}
};



//#######################################################
//##### PART : template class less... ###################
//#######################################################

//#######################################################
//----------- template class lessNodesCompare -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class lessNodesCompare
{
public:
        bool operator()(
                        const Node&lt;SYMBOL, WEIGHT&gt;* const left_i,
                        const Node&lt;SYMBOL, WEIGHT&gt;* const right_i
                        )
        {
                return (left_i-&gt;weight_ &lt; right_i-&gt;weight_);
        }
};


//#######################################################
//------- template class lessNodesCorrectingCompare01 -----
template &lt;typename SYMBOL, typename WEIGHT&gt;
class lessNodesCorrectingCompare01
{
public:
        bool operator()(
                        const Node&lt;SYMBOL, WEIGHT&gt;* const left_i,
                        const Node&lt;SYMBOL, WEIGHT&gt;* const right_i
                        )
        {
                return ((left_i-&gt;weight_ == right_i-&gt;weight_) ? (!(left_i-&gt;is_TerminalNode_)) : (left_i-&gt;weight_ &lt; right_i-&gt;weight_));
        }
};



//#######################################################
//------- template class lessNodesCorrectingCompare02 -----
template &lt;typename SYMBOL, typename WEIGHT&gt;
class lessNodesCorrectingCompare02
{
public:
        bool operator()(
                        const Node&lt;SYMBOL, WEIGHT&gt;* const left_i,
                        const Node&lt;SYMBOL, WEIGHT&gt;* const right_i
                        )
        {
                return ((left_i-&gt;is_TerminalNode_ == right_i-&gt;is_TerminalNode_) ? (left_i-&gt;weight_ &lt; right_i-&gt;weight_) : (!(left_i-&gt;is_TerminalNode_)));
        }
};


//#######################################################
//----------- template class lessCellsCompare -----------
template &lt;typename SYMBOL, typename WEIGHT&gt;
class lessCellsCompare
{
public:
        bool operator()(
                        const Cell&lt;SYMBOL, WEIGHT&gt;& left_i,
                        const Cell&lt;SYMBOL, WEIGHT&gt;& right_i
                        )
        {

                return (left_i.data_weight_ &lt; right_i.data_weight_);
        }
};




//#######################################################
//----------- template class lessVectorsAlterCompare -----------
template &lt;typename T1&gt;
class lessVectorsAlterCompare
{
public:
        bool operator()(
                        const vector&lt;T1&gt;&       left_i,
                        const vector&lt;T1&gt;&       right_i
                        )
        {
                if (left_i.size () &lt; right_i.size ())
                {
                        return true;
                }

                if (left_i.size () &gt; right_i.size ())
                {
                        return false;
                }

                return (left_i &lt; right_i);
        }
};



<a NAME="label_BasicHuffmanTree_class"></a>
//#######################################################
//##### PART : template class <b><a href="#label_BasicHuffmanTree_method">BasicHuffmanTree</a></b> ##########
//############ <font color="FF00FF"><b>Definition</b></font> ###############################
//#######################################################


//#######################################################
//----------- template class BasicHuffmanTree -----------
template &lt;typename SYMBOL, typename WEIGHT, unsigned int ARY&gt;
class BasicHuffmanTree
{
typedef map&lt;SYMBOL, Cell&lt;SYMBOL, WEIGHT&gt;, less&lt;SYMBOL&gt; &gt; Tree_MAP_SYMBOLS;
typedef map&lt;vector&lt;CODE&gt;, SYMBOL, less&lt;vector&lt;CODE&gt; &gt; &gt; Tree_MAP_HUFFMAN_DECODING;

        private :
                Tree_MAP_SYMBOLS                mapAlphabet_;
                Tree_MAP_HUFFMAN_DECODING       mapHuffmanCodes_;
                InternalNode&lt;SYMBOL, WEIGHT&gt;    rootNode_;
                vector&lt;vector&lt;CODE&gt; &gt;           vectorHuffmanCodes_;


                void    createAllTerminalNodes (
                                const vector&lt;Cell&lt;SYMBOL, WEIGHT&gt; &gt;&    data_vector_i,
                                vector&lt;Node&lt;SYMBOL, WEIGHT&gt;*&gt;&          vectorHuffmanProcess_i
                                );
                void    createInternalNode (
                                vector&lt;Node&lt;SYMBOL, WEIGHT&gt;*&gt;&          vectorHuffmanProcess_i,
                                int                                     cur_stage_i
                                );

                void    createHuffmanTree (
                                vector&lt;Node&lt;SYMBOL, WEIGHT&gt;*&gt;&          vectorHuffmanProcess_i
                                );

                void    doBeautyTreatment (
                                vector&lt;Node&lt;SYMBOL, WEIGHT&gt;*&gt;&          vectorHuffmanProcess_i
                                );


                void    storeHuffmanCodes ();


                bool            encodeOneSymbol (
                                        const SYMBOL&   symbol_i,
                                        vector&lt;CODE&gt;&   path_o)
                                        const;


                bool            decodeOneSymbol (
                                        const vector&lt;CODE&gt;&     encoded_msg_i,
                                        unsigned int&           cur_start_position_io,
                                        unsigned int&           cur_symbol_number_io,
                                        vector&lt;CODE&gt;&           cur_symbol_code_o,
                                        SYMBOL&                 cur_symbol_value_o
                                        ) const;

                bool            decodeOneSymbol (
                                        const vector&lt;CODE&gt;&     encoded_symbol_code_i,
                                        SYMBOL&                 decoded_symbol_value_o
                                        ) const;

                bool            testAllCodes (bool show_i = false) const;

                void            showHuffmanProcessStatus (
                                        vector&lt;Node&lt;SYMBOL, WEIGHT&gt;*&gt;&  vectorHuffmanProcess_i,
                                        int                             cur_stage_i = 0,
                                        const string&                   msg_i = string ()
                                        ) const;

                static void     print_show_title_S (
                                        const string&   spaces_offset_i,