BasicServiceOptions.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 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() { }
};

__END_NS_SSRC_WISP_UTILITY

#endif