An Overlay-based
Virtual Network Substrate
SpoVNet

Changeset 7535


Ignore:
Timestamp:
Feb 5, 2010, 9:08:33 AM (9 years ago)
Author:
Christoph Mayer
Message:

-missing doxygen in interface

Location:
source/ariba
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • source/ariba/AribaModule.cpp

    r7532 r7535  
    5959
    6060use_logging_cpp(AribaModule);
    61 const string AribaModule::BootstrapMechanismNames[5] = {"invalid", "static", "broadcast", "mdns", "sdp"};
     61const string AribaModule::BootstrapMechanismNames[5]
     62         = {"invalid", "static", "broadcast", "mdns", "sdp"};
    6263
    6364AribaModule::AribaModule()
  • source/ariba/AribaModule.h

    r7532 r7535  
    157157private:
    158158
    159         // bootstrap mechanisms
     159        /**
     160         * Available bootstrap mechanisms
     161         */
    160162        enum BootstrapMechanism {
    161163                BootstrapMechanismInvalid = 0,
     
    167169        static const string BootstrapMechanismNames[5];
    168170
    169         // bootstrap node
     171        /**
     172         * bootstrap node information
     173         */
    170174        class BootstrapNode {
    171175        public:
     
    189193        };
    190194
    191         // bootstrap info
     195        /*
     196         * bootstrap info, all bootstrap nodes
     197         * for a specific spovnet
     198         */
    192199        class BootstrapInfo {
    193200        public:
     
    203210                vector<BootstrapNode> nodes;
    204211        };
    205         vector<BootstrapInfo> bootstrapNodes;
     212
     213        vector<BootstrapInfo> bootstrapNodes; //< all available bootstrap information
    206214
    207215protected:
     
    210218        bool started; //< flag, if module has been started
    211219
    212         // bootstrap node management
     220        /**
     221         * bootstrap node management
     222         * add a bootstrap node
     223         */
    213224        void addBootstrapNode(
    214225                        const Name& spovnet,
     
    217228                        const BootstrapMechanism& mechanism
    218229                        );
     230
     231        /**
     232         * bootstrap node management
     233         * add a bootstrap node
     234         */
    219235        void addBootstrapNode(
    220236                        const Name& spovnet,
     
    222238                        );
    223239
     240        /**
     241         * bootstrap node management
     242         * get all available bootstrap mechanisms
     243         * where bootstrap nodes are available for
     244         */
    224245        vector<AribaModule::BootstrapMechanism> getBootstrapMechanisms(
    225246                        const Name& spovnet
    226247                        ) const;
    227248
     249        /**
     250         * get a endpoint descriptor for a spovnet
     251         * using a specific bootstrap mechanisms.
     252         * will currently only work with static
     253         */
    228254        const communication::EndpointDescriptor* getBootstrapNode(
    229255                        const Name& spovnet,
     
    231257                        ) const;
    232258
     259        /**
     260         * get the info field associated for a given
     261         * spovnet through a given mechanism
     262         */
    233263        string getBootstrapInfo(
    234264                        const Name& spovnet,
     
    236266                        ) const;
    237267
    238         communication::BaseCommunication* base_comm;
    239         SideportListener* sideport_sniffer;
     268        communication::BaseCommunication* base_comm; //< the base communication
     269        SideportListener* sideport_sniffer; //< the sideport listener
    240270};
    241271
  • source/ariba/CommunicationListener.h

    r7468 r7535  
    6161
    6262public:
    63         static CommunicationListener DEFAULT;
     63        static CommunicationListener DEFAULT; //< default implementation
    6464
    6565protected:
    6666
     67        /**
     68         * Construct a communication listener
     69         */
    6770        CommunicationListener();
     71
     72        /**
     73         * Destruct a communication listener
     74         */
    6875        virtual ~CommunicationListener();
    6976
    7077        // --- link events ---
    7178
     79        /**
     80         * Event called when a link goes up
     81         * @param lnk The id of the link
     82         * @param remote The remote node where the link ends
     83         */
    7284        virtual void onLinkUp(const LinkID& lnk, const NodeID& remote);
    7385
     86        /**
     87         * Event called when a link goes down
     88         * @param lnk The id of the link
     89         * @param remote The remote node where the link ends
     90         */
    7491        virtual void onLinkDown(const LinkID& lnk, const NodeID& remote);
    7592
     93        /**
     94         * Event called when a link has changed,
     95         * e.g. through mobility
     96         * @param lnk The id of the link
     97         * @param remote The remote node where the link ends
     98         */
    7699        virtual void onLinkChanged(const LinkID& lnk, const NodeID& remote);
    77100
     101        /**
     102         * Event called when a link has failed
     103         * @param lnk The id of the link
     104         * @param remote The remote node where the link ends
     105         */
    78106        virtual void onLinkFail(const LinkID& lnk, const NodeID& remote);
    79107
     108        /**
     109         * Request from remote node to open up a link
     110         * @param remote The remote node that requests the new link
     111         */
    80112        virtual bool onLinkRequest(const NodeID& remote);
    81113
    82114        // --- general receive method ---
    83115
     116        /**
     117         * Called when a message is incoming
     118         * @param msg The data message that is received
     119         * @param remote The remote node that sent the message
     120         * @param lnk The link id of the link where the message is received
     121         */
    84122        virtual void onMessage(const DataMessage& msg, const NodeID& remote,
    85123                        const LinkID& lnk = LinkID::UNSPECIFIED);
     
    87125        // --- dht functionality ---
    88126
     127        /**
     128         * Called when a key has been resolved in the DHT
     129         * @param key The key that was requested
     130         * @param value the data items the key was resolved to
     131         */
    89132        virtual void onKeyValue( const Data& key, const vector<Data>& value );
    90133
  • source/ariba/DataMessage.h

    r7500 r7535  
    3333class DataMessage {
    3434private:
    35         void* data;
    36         size_t size;
     35        void* data; //< internal buffer pointer
     36        size_t size; //< internal buffer pointer size
    3737public:
    38         static const DataMessage UNSPECIFIED;
     38        static const DataMessage UNSPECIFIED; //< default implementation of a data message
    3939
     40        /**
     41         * Default constructor for a data message
     42         */
    4043        inline DataMessage() {
    4144                this->data = NULL;
     
    4346        }
    4447
     48        /**
     49         * Constructor for a data message
     50         * @param data Data buffer to carry in the message
     51         * @param size Size of the buffer pointed to
     52         */
    4553        inline DataMessage( const void* data, const size_t size ) {
    4654                this->data = const_cast<void*>(data);
     
    4856        }
    4957
     58        /**
     59         * Copy constructor for a data message
     60         * @param message The other message to copy from
     61         */
    5062        inline DataMessage(const DataMessage& message){
    5163                this->data = message.data;
     
    5466
    5567#ifdef USE_MESSAGE_UTILITY
     68        /**
     69         * Construct a data message from a normal message
     70         * @param message The normal message to store
     71         */
    5672        inline DataMessage( const Message* message ) {
    5773                this->data = (void*)const_cast<Message*>(message);
     
    5975        }
    6076
     77        /**
     78         * Construct a data message from a normal message
     79         * @param message The normal message to store
     80         */
    6181        inline DataMessage( const Message& message ) {
    6282                this->data = (void*)const_cast<Message*>(&message);
     
    6484        }
    6585
     86        /**
     87         * Get the internal message when constructued through one
     88         * @return pointer to the message
     89         */
    6690        inline Message* getMessage() const {
    6791                if (isData()) {
     
    7195        }
    7296
     97        /**
     98         * Conversion function to convert to Message*
     99         * @return internal message
     100         */
    73101        inline operator Message* () const {
    74102                return getMessage();
     
    76104#endif
    77105
     106        /**
     107         * Is the data message a normal message?
     108         * @return true, if the data message is a normal message
     109         */
    78110        inline bool isMessage() const {
    79111                return size == ~(size_t)0;
    80112        }
    81113
     114        /**
     115         * Is the data message a data message
     116         * @return true, if the data message is not a normal message
     117         */
    82118        inline bool isData() const {
    83119                return !isMessage();
    84120        }
    85121
     122        /**
     123         * Directly access the internal data pointer
     124         * @return internal data pointer
     125         */
    86126        inline void* getData() const {
    87127                return data;
    88128        }
    89129
     130        /**
     131         * Get the size of the internal buffer
     132         * @return internal buffer size
     133         */
    90134        inline size_t getSize() const {
    91135                return size;
    92136        }
    93137
     138        /**
     139         * Is the data message invalid?
     140         * @return true, if data message is invalid
     141         */
    94142        inline bool isUnspecified() const {
    95143                return data == NULL;
    96144        }
     145
    97146};
    98147
  • source/ariba/LinkProperties.h

    r7468 r7535  
    5353namespace ariba {
    5454
     55/**
     56 * Link properties storage. Currently empty but will
     57 * contain properties to create the link in the future
     58 */
    5559class LinkProperties {
    5660public:
     61        /**
     62         * Constructor of LinkProperties
     63         */
    5764        LinkProperties();
    58         ~LinkProperties();
    5965
     66        /**
     67         * Destructor of LinkProperties
     68         */
     69        virtual ~LinkProperties();
     70
     71        /**
     72         * Convert to readable string
     73         * @return string representation
     74         */
    6075        string toString() const;
     76
     77        /**
     78         * Default instance of LinkProperties
     79         */
    6180        static const LinkProperties DEFAULT;
    6281};
  • source/ariba/Message.h

    r7468 r7535  
    4040#define TIDYMESSAGE_H_
    4141
    42 /** THIS FILE IS ABOUT TO BE DEPRECATED !! */
    43 
    4442#include <inttypes.h>
    4543#include "ariba/utility/messages.h"
  • source/ariba/Name.h

    r6919 r7535  
    149149
    150150private:
    151         uint8_t* _bytes;
    152         int _length;
    153         bool _copy;
    154         bool _hreadable;
     151        uint8_t* _bytes; //< internal pointer
     152        int _length; //< length of internal pointer
     153        bool _copy; //< is the buffer a real copy
     154        bool _hreadable; //< is the name human readable
    155155
    156156        void init(const char* name, int len, bool copy, bool hreadable);
  • source/ariba/Node.h

    r7532 r7535  
    182182         * the node name of the remote node, if known -- otherwise it returns
    183183         * an unspecified name.
    184          *
    185          * TODO: RFE -- send request to remote node and inform service.
    186184         *
    187185         * @return A node's name or an unspecified name, if unknown
     
    325323        string getName() const;
    326324
    327 
    328325protected:
    329326        // friends
     
    334331        AribaModule& ariba_mod;                //< ariba module
    335332        SpoVNetID spovnetId;                   //< current spovnet id
    336         NodeID nodeId;                        //< current node id
     333        NodeID nodeId;                            //< current node id
    337334        overlay::BaseOverlay* base_overlay;    //< the base overlay
     335
    338336};
    339337
  • source/ariba/SpoVNetProperties.h

    r7468 r7535  
    6666class SpoVNetProperties {
    6767public:
     68        /**
     69         * Different types of overlays that are supported
     70         */
    6871        enum OverlayType {
    6972                ONE_HOP_OVERLAY = 0,
Note: See TracChangeset for help on using the changeset viewer.