Scale Stack 0.3 Developer Documentation

scalestack/kernel/module.h

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * 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.apache.org/licenses/LICENSE-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 SCALESTACK_KERNEL_MODULE_H
#define SCALESTACK_KERNEL_MODULE_H

#include <stdint.h>
#include <string>
#include <vector>

#include <scalestack/kernel/logger.h>
#include <scalestack/kernel/macros.h>

namespace scalestack
{
namespace kernel
{

class core;
class option;

class SCALESTACK_API module: public logger
{
public:

  typedef struct
  {
    uint32_t api_version;
    const char* name;
    const char* version;
    const char* author;
    const char* title;
    const char* license;
    const char* dependencies;
    void (*options)(module&);
    void (*start)(module&);
    void (*stop)(module&);
    void (*run)(module&);
    void (*reconfigure)(module&);
  } definition;

  ~module();

  /* Make the base class method public. */
  using logger::get_threshold;

  /* Make the base class method public. */
  using logger::set_threshold;

  core& get_core(void) const;

  const std::string& get_name(void) const;

  std::string get_normalized_name(void) const;

  const std::string& get_pathname(void) const;

  const std::string& get_version(void) const;

  const std::string& get_author(void) const;

  const std::string& get_title(void) const;

  const std::string& get_license(void) const;

  const std::string& get_dependencies(void) const;

  size_t get_parent_count(void) const;

  module* begin_parent(void);

  module* next_parent(void);

  size_t get_child_count(void) const;

  module* begin_child(void);

  module* next_child(void);

  bool is_loaded(void) const;

  option& add_option(const std::string& name,
                     const std::string& help,
                     const std::string& value_name,
                     const std::string& default_value);

  option& get_option(const std::string& name) const;

  size_t get_option_count(void) const;

  option* begin_option(void);

  option* next_option(void);

  void run(void);

  static std::string normalize_name(const std::string& name);

private:

  SCALESTACK_LOCAL
  module(core& core, const std::string& name, size_t threshold);

  SCALESTACK_LOCAL
  module(const module&);

  SCALESTACK_LOCAL
  module& operator=(const module&);

  SCALESTACK_LOCAL
  void _load(void);

  SCALESTACK_LOCAL
  void _load_dependencies(void);

  SCALESTACK_LOCAL
  void _unload(void);

  SCALESTACK_LOCAL
  void _start(void);

  SCALESTACK_LOCAL
  void _run(void);

  SCALESTACK_LOCAL
  void _reconfigure(void);

  SCALESTACK_LOCAL
  void _open_object(int flags);

  SCALESTACK_LOCAL
  void _close_object(void);

  SCALESTACK_LOCAL
  option* _get_option(const std::string& name) const;

  SCALESTACK_LOCAL
  option& _get_or_add_option(const std::string& name);

  SCALESTACK_LOCAL
  void _set_option_value(const std::string& name, const std::string& value);

  SCALESTACK_LOCAL
  void _check_options(void) const;

  SCALESTACK_LOCAL
  void _set_fatal_message(const char* format, std::va_list arguments) const;

  SCALESTACK_LOCAL
  void _log_message(log::level log_level,
                    const char* format,
                    std::va_list arguments) const;

  SCALESTACK_LOCAL
  void _print_help(void);

  SCALESTACK_LOCAL
  void _print_config(void);

  typedef std::vector<module*> modules;
  typedef std::vector<option*> options;

  bool _is_loading;
  bool _is_loaded;
  bool _is_started;
  bool _need_run;
  bool _need_reconfigure;
  core& _core;
  void* _handle;
  definition* _definition;
  std::string _name;
  std::string _pathname;
  std::string _version;
  std::string _author;
  std::string _title;
  std::string _license;
  std::string _dependencies;
  modules _parents;
  modules::iterator _parent_iterator;
  modules _children;
  modules::iterator _child_iterator;
  options _options;
  options::iterator _option_iterator;

  friend class core;
};

} /* namespace kernel */
} /* namespace scalestack */

#define SCALESTACK_KERNEL_MODULE(options, start, stop, run, reconfigure) \
  SCALESTACK_API scalestack::kernel::module::definition \
  _scalestack_kernel_module_definition = \
  { \
    SCALESTACK_CURRENT_API_VERSION, \
    SCALESTACK_QUOTE_VALUE(PANDORA_MODULE_NAME), \
    PANDORA_MODULE_VERSION, \
    PANDORA_MODULE_AUTHOR, \
    PANDORA_MODULE_TITLE, \
    SCALESTACK_QUOTE_VALUE(PANDORA_MODULE_LICENSE), \
    PANDORA_MODULE_DEPENDENCIES, \
    options, \
    start, \
    stop, \
    run, \
    reconfigure \
  }

#endif /* SCALESTACK_KERNEL_MODULE_H */

---