model/plc-node.h

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2012 University of British Columbia, Vancouver
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Alexander Schloegl <alexander.schloegl@gmx.de>
 */

#ifndef PLC_NODE_H_
#define PLC_NODE_H_

#include <map>
#include <set>
#include <list>
#include <string>

#include <ns3/object.h>
#include <ns3/type-id.h>
#include <ns3/vector.h>

#include "plc-defs.h"
#include "plc-time.h"
#include "plc-value.h"
#include "plc-edge.h"
#include "plc-outlet.h"
#include "plc-backbone.h"

namespace ns3 {

class PLC_Graph;
class PLC_Line;
class PLC_Outlet;
class PLC_Channel;

class PLC_Node : public Object
{
        friend class PLC_Graph;
        friend class PLC_Outlet;

public:
        static TypeId GetTypeId (void);

        PLC_Node ();
        ~PLC_Node ();

        Vector3D GetPosition (void) { return m_position; }

        void SetPosition (Vector3D pos) { m_position = pos; }

        void SetPosition(double pos_x, double pos_y, double pos_z);

        void SetImpedance(Ptr<PLC_Impedance> impedance);

        Ptr<PLC_Impedance> GetImpedancePtr (void) { return m_impedance; }

        PLC_Impedance *GetImpedancePeekPtr (void) const { return PeekPointer(m_impedance); }

        unsigned int GetVertexId (void) { return m_vertex_id; }

        Ptr<PLC_Outlet> GetOutlet (void) { return this->m_outlet; }

        PLC_Outlet *GetOutletPeekPtr (void);

        bool HasOutlet (void) { return m_outlet == NULL ? false : true; }

        bool IsOpenCircuit (void)       { return m_open_circuit; }

        void OpenCircuit (void)         { m_open_circuit = true; }

        void CloseCircuit (void);


        void AddEdge (Ptr<PLC_Node> to, Ptr<PLC_Edge> edge);

        size_t GetNumEdges (void) { return m_edges.size(); }

        PLC_Edge *GetEdge (PLC_Node *node);

        PLC_NodeOutEdgesMap GetEdges (void);

        void AssociateBackboneBranch (Ptr<PLC_BackboneBranch> backboneBranch);

        PLC_NodeOutEdgesMap::iterator OutEdgesBegin (void) { return m_edges.begin(); }

        PLC_NodeOutEdgesMap::iterator OutEdgesEnd (void) { return m_edges.end(); }

        void SetName(std::string name) { m_name = name; }

        std::string GetName(void) { return m_name; }

        void Lock(void) { m_node_mutex.Lock(); }

        void Unlock(void) { m_node_mutex.Unlock(); }

        bool IsTimeVariant(void);

        Ptr<PLC_Graph> GetGraph(void) { return this->m_graph; }

        Ptr<PLC_Channel> GetChannel(void);

        void SetGraph(Ptr<PLC_Graph> graph);

        void SetOutlet(Ptr<PLC_Outlet> outlet);

        static uint64_t GetImpedanceHashSum(void) { return m_impedance_hash_sum; }

protected:
        virtual void DoStart(void);
        virtual void DoDispose(void);

        static uint64_t m_impedance_hash_sum;

        Vector3D m_position;
        mutable PLC_Mutex       m_node_mutex;
        unsigned int m_vertex_id;
        bool m_open_circuit;

        Ptr<PLC_Graph>          m_graph;
        Ptr<PLC_Impedance>      m_impedance;
        Ptr<PLC_Outlet>         m_outlet;

        PLC_NodeOutEdgesMap m_edges;
        std::set<Ptr<PLC_BackboneBranch> > m_associated_backbone_branches;

        std::string m_name;
};

}

#endif /* PLC_NODE_H_ */