arzmq-sys 0.5.4

Low-level bindings to the zeromq library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/*********************************************************************
 *
 * Authorization TO USE AND DISTRIBUTE
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that: 
 *
 * (1) source code distributions retain this paragraph in its entirety, 
 *  
 * (2) distributions including binary code include this paragraph in
 *     its entirety in the documentation or other materials provided 
 *     with the distribution, and 
 *
 * (3) all advertising materials mentioning features or use of this 
 *     software display the following acknowledgment:
 * 
 *      "This product includes software written and developed 
 *       by Brian Adamson and Joe Macker of the Naval Research 
 *       Laboratory (NRL)." 
 *         
 *  The name of NRL, the name(s) of NRL  employee(s), or any entity
 *  of the United States Government may not be used to endorse or
 *  promote  products derived from this software, nor does the 
 *  inclusion of the NRL written and developed software  directly or
 *  indirectly suggest NRL or United States  Government endorsement
 *  of this product.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 ********************************************************************/
 
#include "ip.h"  	// for hdr_ip def
#include "flags.h"  // for hdr_flags def

#include "nsMgenAgent.h"
#include "nsNormAgent.h" 
static class NsNormAgentClass : public TclClass
{
	public:
		NsNormAgentClass() : TclClass("Agent/NORM") {}
	 	TclObject* create(int argc, const char*const* argv) 
			{return (new NsNormAgent());}
} class_norm_agent;	


NsNormAgent::NsNormAgent()
  : NormSimAgent(GetTimerMgr(), GetSocketNotifier())
{
 
}  

NsNormAgent::~NsNormAgent()
{    
}

bool NsNormAgent::OnStartup(int argc, const char*const* argv)
{

    if (ProcessCommands(argc, argv))
    {
        return true;
    }
    else
    {
        fprintf(stderr, "NsNormAgent::OnStartup() error processing commands\n");
        return false;
    }
} // end NsNormAgent::OnStartup()

void NsNormAgent::OnShutdown()
{
    NormSimAgent::Stop(); 
}  // end NsNormAgent::OnShutdown()

bool NsNormAgent::ProcessCommands(int argc, const char*const* argv) 
{   
    // Process commands, passing unknown commands to base Agent class
    int i = 1;
    while (i < argc)
    {
        // Intercept ns-specific commands
        if (!strcmp(argv[i], "attach-mgen"))
        {
            // (TBD) this could be done as a generic NormSimAgent command
            // Attach Agent/MGEN to this NormSimAgent 
            if (++i >= argc)
            {
                DMSG(0, "NsNormAgent::ProcessCommands() ProcessCommand(attach-mgen) error: insufficent arguments\n");
                return false;
            } 
            Tcl& tcl = Tcl::instance();  
            msg_sink = dynamic_cast<ProtoMessageSink*>(tcl.lookup(argv[i]));

            if (msg_sink)
            {
                i++;
                continue;
            }
            else
            {
                DMSG(0, "NsNormAgent::ProcessCommands() ProcessCommand(attach-mgen) error: invalid mgen agent\n");
                return false;
            }
        }
        else if (!strcmp(argv[i], "active"))
        {
            // query agent's current state of activity
            Tcl& tcl = Tcl::instance(); 
            if (IsActive())
                Tcl_SetResult(tcl.interp(), "on", TCL_STATIC);
                //sprintf(tcl.result(), "on");
            else
                Tcl_SetResult(tcl.interp(), "off", TCL_STATIC);
            i++;
            continue;
        }
        // Other commands are interpreted by the NormSimAgent base class
        NormSimAgent::CmdType cmdType = CommandType(argv[i]);
        switch (cmdType)
        {
            case NormSimAgent::CMD_NOARG:
                if (!ProcessCommand(argv[i], NULL))
                {
                    DMSG(0, "NsNormAgent::ProcessCommands() ProcessCommand(%s) error\n", 
                            argv[i]);
                    return false;
                }
                i++;
                break;
                
            case NormSimAgent::CMD_ARG:
                if (!ProcessCommand(argv[i], argv[i+1]))
                {
                    DMSG(0, "NsNormAgent::ProcessCommands() ProcessCommand(%s, %s) error\n", 
                            argv[i], argv[i+1]);
                    return false;
                }
                i += 2;
                break;
                
            case NormSimAgent::CMD_INVALID:
                return false;
        }
    }
    return true; 
}  // end NsNormAgent::ProcessCommands()