BasicServiceOptions.h

Go to the documentation of this file.

  /* Copyright 2006-2013 Savarese Software Research Corporation.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.savarese.com/software/ApacheLicense-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #ifndef __SSRC_WISP_UTILITY_BASIC_SERVICE_OPTIONS_H
  #define __SSRC_WISP_UTILITY_BASIC_SERVICE_OPTIONS_H
  
  #include <ssrc/wisp-packages.h>
  
  #include <boost/program_options.hpp>
  
  __BEGIN_NS_SSRC_WISP_UTILITY
  
  class BasicServiceOptions {
  public:
   // Allocate 64k for message. That's below the max Spread message limit
   // and hopefully large enough to accommodate anything we throw at it.
   enum { DefaultServiceMessageCapacity = 1u << 16 };
  
  private:
   boost::program_options::options_description basic_description;
  
  protected:
  
   BasicServiceOptions() :
   basic_description("Basic"), description("Options"),
   help(false), connection(),
   name(), capacity(DefaultServiceMessageCapacity),
   call_timeout(600),
   locale()
   {
   using namespace boost::program_options;
  
   basic_description.add_options()
   ("help,h", "Display this help message and exit.")
   ("connection,c", value<std::string>(&connection),
   "Specify the name of the Spread daemon to connect to.")
   ("name,n", value<std::string>(&name),
   "The Spread private name to assign the service.")
   ("capacity,C",
   value<unsigned int>(&capacity)->default_value(DefaultServiceMessageCapacity),
   "The ssrc::spread::Message capacity the service requires for message "
   "sends. This value should equal the size in bytes of the largest "
   "message the service will ever send.")
   ("call-timeout,t",
   value<unsigned int>(&call_timeout)->default_value(600),
   "The number of seconds to wait before cancelling an asynchronous call "
   "that has not yet returned.")
   ("locale,l", value<std::string>(&locale),
   "The locale to use for ctype string interpretation.");
  
   description.add(basic_description);
   }
  
   virtual void store(int argc, char *argv[]) {
   namespace po = boost::program_options;
   po::variables_map vm;
   po::store(po::parse_command_line(argc, argv, description), vm);
   notify(vm);
   po::notify(vm);
   }
  
   virtual void notify(boost::program_options::variables_map & vm) {
   namespace po = boost::program_options;
   help = (vm.count("help") > 0);
   if(!help) {
   // In order to set help when no options are specified, we can't
   // check vm.empty() because default values add to vm.size().
   // Therefore, we check that no non-default values are specified.
   po::variables_map::iterator it = vm.begin();
   while(it != vm.end()) {
   if(!it->second.empty() && !it->second.defaulted())
   break;
   ++it;
   }
   help = (it == vm.end());
   }
   }
  
  public:
   boost::program_options::options_description description;
   bool help;
   std::string connection;
   std::string name;
   unsigned int capacity;
   unsigned int call_timeout;
   std::string locale;
  
   virtual ~BasicServiceOptions() = default;
  };
  
  __END_NS_SSRC_WISP_UTILITY
  
  #endif