Moved pvget/pvput/pvinfo/eget programs into pvtoolsSrc

These programs are intended for users, they are not tests.

pvtoolsSrc/pvinfo.cpp

@@ -0,0 +1,190 @@
+#include <iostream>
+#include <pv/clientFactory.h>
+#include <pv/pvAccess.h>
+
+#include <stdio.h>
+#include <epicsStdlib.h>
+#include <epicsGetopt.h>
+#include <epicsThread.h>
+#include <pv/logger.h>
+#include <pv/lock.h>
+
+#include <vector>
+#include <string>
+#include <sstream>
+
+#include <pv/event.h>
+#include <epicsExit.h>
+
+#include "pvutils.cpp"
+
+using namespace std;
+using namespace std::tr1;
+using namespace epics::pvData;
+using namespace epics::pvAccess;
+
+
+#define DEFAULT_TIMEOUT 3.0
+
+double timeOut = DEFAULT_TIMEOUT;
+
+void usage (void)
+{
+    fprintf (stderr, "\nUsage: pvinfo [options] <PV name>...\n\n"
+    "  -h: Help: Print this message\n"
+    "options:\n"
+    "  -w <sec>:          Wait time, specifies timeout, default is %f second(s)\n"
+    "  -d:                Enable debug output\n"
+    "  -c:                Wait for clean shutdown and report used instance count (for expert users)"
+    "\nExample: pvinfo double01\n\n"
+             , DEFAULT_TIMEOUT);
+}
+
+
+/*+**************************************************************************
+ *
+ * Function:	main
+ *
+ * Description:	pvinfo main()
+ * 		Evaluate command line options, set up PVA, connect the
+ * 		channels, print the data as requested
+ *
+ * Arg(s) In:	[options] <pv-name>...
+ *
+ * Arg(s) Out:	none
+ *
+ * Return(s):	Standard return code (0=success, 1=error)
+ *
+ **************************************************************************-*/
+
+int main (int argc, char *argv[])
+{
+    int opt;                    /* getopt() current option */
+    bool debug = false;
+    bool cleanupAndReport = false;
+
+    setvbuf(stdout,NULL,_IOLBF,BUFSIZ);    /* Set stdout to line buffering */
+
+    while ((opt = getopt(argc, argv, ":hw:dc")) != -1) {
+        switch (opt) {
+        case 'h':               /* Print usage */
+            usage();
+            return 0;
+        case 'w':               /* Set PVA timeout value */
+            if(epicsScanDouble(optarg, &timeOut) != 1 || timeOut <= 0.0)
+            {
+                fprintf(stderr, "'%s' is not a valid timeout value "
+                        "- ignored. ('pvget -h' for help.)\n", optarg);
+                timeOut = DEFAULT_TIMEOUT;
+            }
+            break;
+        case 'd':               /* Debug log level */
+            debug = true;
+            break;
+        case 'c':               /* Clean-up and report used instance count */
+            cleanupAndReport = true;
+            break;
+        case '?':
+            fprintf(stderr,
+                    "Unrecognized option: '-%c'. ('pvinfo -h' for help.)\n",
+                    optopt);
+            return 1;
+        case ':':
+            fprintf(stderr,
+                    "Option '-%c' requires an argument. ('pvinfo -h' for help.)\n",
+                    optopt);
+            return 1;
+        default :
+            usage();
+            return 1;
+        }
+    }
+
+    int nPvs = argc - optind;       /* Remaining arg list are PV names */
+    if (nPvs < 1)
+    {
+        fprintf(stderr, "No pv name(s) specified. ('pvinfo -h' for help.)\n");
+        return 1;
+    }
+
+    vector<string> pvs;     /* Array of PV names */
+    for (int n = 0; optind < argc; n++, optind++)
+        pvs.push_back(argv[optind]);       /* Copy PV names from command line */
+
+
+    SET_LOG_LEVEL(debug ? logLevelDebug : logLevelError);
+
+    std::cout << std::boolalpha;
+
+    bool allOK = true;
+
+    {
+        Requester::shared_pointer requester(new RequesterImpl("pvinfo"));
+    
+        ClientFactory::start();
+        ChannelProvider::shared_pointer provider = getChannelAccess()->getProvider("pva");
+    
+        // first connect to all, this allows resource (e.g. TCP connection) sharing
+        vector<Channel::shared_pointer> channels(nPvs);
+        for (int n = 0; n < nPvs; n++)
+        {
+            shared_ptr<ChannelRequesterImpl> channelRequesterImpl(new ChannelRequesterImpl()); 
+            channels[n] = provider->createChannel(pvs[n], channelRequesterImpl);
+        }
+        
+        // for now a simple iterating sync implementation, guarantees order
+        for (int n = 0; n < nPvs; n++)
+        {
+            Channel::shared_pointer channel = channels[n];
+            shared_ptr<ChannelRequesterImpl> channelRequesterImpl = dynamic_pointer_cast<ChannelRequesterImpl>(channel->getChannelRequester());
+             
+            if (channelRequesterImpl->waitUntilConnected(timeOut))
+            {
+                shared_ptr<GetFieldRequesterImpl> getFieldRequesterImpl(new GetFieldRequesterImpl(channel));
+                channel->getField(getFieldRequesterImpl, "");
+
+                if (getFieldRequesterImpl->waitUntilFieldGet(timeOut))
+            	{
+                    Structure::const_shared_pointer structure =
+                            dynamic_pointer_cast<const Structure>(getFieldRequesterImpl->getField());
+
+                    channel->printInfo();
+                    if (structure)
+                    {
+                        String s;
+                        structure->toString(&s);
+                        std::cout << s << std::endl << std::endl;
+                    }
+                    else
+                    {
+                        std::cout << "(null introspection data)" << std::endl << std::endl;
+                    }
+            	}
+            	else
+            	{
+            		allOK = false;
+                    channel->destroy();
+                    std::cerr << "[" << channel->getChannelName() << "] failed to get channel introspection data" << std::endl;
+            	}
+            }
+            else
+            {
+                allOK = false;
+                channel->destroy();
+                std::cerr << "[" << channel->getChannelName() << "] connection timeout" << std::endl;
+            }
+        }    
+
+        ClientFactory::stop();
+    }
+
+    if (cleanupAndReport)
+    {
+        // TODO implement wait on context
+        epicsThreadSleep ( 3.0 );
+        //std::cout << "-----------------------------------------------------------------------" << std::endl;
+        //epicsExitCallAtExits();
+    }
+
+    return allOK ? 0 : 1;
+}