/shared/development/google_code/rssoft/libccsoft/lib/CC_TreeNode.h

Go to the documentation of this file.

/*
 Copyright 2013 Edouard Griffiths <f4exb at free dot fr>

 This file is part of CCSoft. A Convolutional Codes Soft Decoding library

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Boston, MA  02110-1301  USA

 Node in the convolutional code tree

 */

#ifndef __CC_TREE_NODE_H__
#define __CC_TREE_NODE_H__

#include <vector>

namespace ccsoft
{

template<typename T_IOSymbol, typename T_Register, typename T_EdgeTag>
class CC_TreeEdge;

template<typename T_IOSymbol, typename T_Register, typename T_EdgeTag>
class CC_TreeNode
{
public:
    CC_TreeNode(unsigned int _id,
            CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag> *_p_incoming_edge,
            float _path_metric,
            int _depth) :
                id(_id),
                p_incoming_edge(_p_incoming_edge),
                path_metric(_path_metric),
                depth(_depth),
                on_final_path(false)
    {}

    ~CC_TreeNode()
    {
        delete_outgoing_edges();
    }

    void add_outgoing_edge(CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag> *p_outgoing_edge)
    {
        p_outgoing_edges.push_back(p_outgoing_edge);
    }

    void delete_outgoing_edges()
    {
        typename std::vector<CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag>*>::iterator e_it = p_outgoing_edges.begin();
    
        for (; e_it != p_outgoing_edges.end(); ++e_it)
        {
            if (*e_it)
            {
                delete *e_it;
                *e_it = 0;
            }
        }

        p_outgoing_edges.clear();
    }

    const std::vector<CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag>*>& get_outgoing_edges() const
    {
        return p_outgoing_edges;
    }
    
    std::vector<CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag>*>& get_outgoing_edges() 
    {
        return p_outgoing_edges;
    }
    
    CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag> *get_incoming_edge()
    {
        return p_incoming_edge;
    }

    float get_path_metric() const
    {
        return path_metric;
    }

    int get_depth() const
    {
        return depth;
    }
    
    unsigned int get_id() const
    {
        return id;
    }

    bool operator<(const CC_TreeNode<T_IOSymbol, T_Register, T_EdgeTag>& other) const
    {
        return path_metric < other.path_metric;
    }

    bool operator>(const CC_TreeNode<T_IOSymbol, T_Register, T_EdgeTag>& other) const
    {
        return path_metric > other.path_metric;
    }

    const std::vector<T_Register>& get_registers() const
    {
        return registers;
    }

    void set_registers(const std::vector<T_Register>& _registers)
    {
        registers = _registers;
    }
    
    void set_on_final_path(bool _on_final_path = true)
    {
        on_final_path = _on_final_path;
    }
    
    bool is_on_final_path()
    {
        return on_final_path;
    }
    
    bool operator<(const CC_TreeNode<T_IOSymbol, T_Register, T_EdgeTag>& other)
    {
        if (path_metric == other.path_metric)
        {
            return id < other.id;
        }
        else
        {
            return path_metric < other.path_metric;
        }
    }

    bool operator>(const CC_TreeNode<T_IOSymbol, T_Register, T_EdgeTag>& other)
    {
        if (path_metric == other.path_metric)
        {
            return id > other.id;
        }
        else
        {
            return path_metric > other.path_metric;
        }
    }

protected:
    unsigned int id; 
    std::vector<CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag>*> p_outgoing_edges; 
    CC_TreeEdge<T_IOSymbol, T_Register, T_EdgeTag> *p_incoming_edge; 
    float path_metric; 
    int depth; 
    std::vector<T_Register> registers; 
    bool on_final_path; 
};

} // namespace ccsoft

#endif // __CC_TREE_NODE_H__