The \a AnnotationType template parameter defines the routing key. This annotation must
support the following operations:
\li Comparison with '<' (\c LessThanComparable concept)
- \li Copy construction and copy assignment (\c Copyable und \c Assignable concepts)
+ \li Copy construction and copy assignment (\c Copyable and \c Assignable concepts)
(e.g. via compiler synthesized copy constructor and assignment operator)
\li Output streaming to an ostream via '\c <<' (for error description purposes) (\c
OutputStreamable concept)
/** \brief Active, queue-based packet source
- The ActiveFeederSource contains a packet queue containing the packets to be precessed. These
+ The ActiveFeederSource contains a packet queue containing the packets to be processed. These
packets are actively fed into the network when it is run with senf::ppi::run() until it is
empty, when senf::ppi::run() will return.
\note senf::ppi::run will return as soon as no events are active. If want you want is to
- precess a set of packets placed into the ActiveFeederSource queue you must make sure,
+ Process a set of packets placed into the ActiveFeederSource queue you must make sure,
that eventually all events in the module are disabled by throttling or other
activities. Otherwise, senf::ppi::run() will \e not return.
/** \brief Log received packets
- This module will log all packets sent to it's input using SENF_LOG to the given log
+ This module will %log all packets sent to it's input using SENF_LOG to the given %log
\a Stream, \a Area and \a Level.
*/
template < class Stream = log::Debug,
#endif
// Custom includes
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
//#include "DumpFormat.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////
This is the container wrapper used for list parsers. The container wrapper will stay valid
after changing the collection. However the container still depends on the packet and will be
invalidated if the Packet is deallocated or if the packet size is changed from without the
- container wrapper (more precisely, it is invalided if the insertion/deletion happens before
+ container wrapper (more precisely, it is invalidated if the insertion/deletion happens before
the vector in the packet data).
The vector container wrapper provides a complete STL random-access sequence interface.
backwards towards outer packets up to \c this. */
void finalizeAll(); ///< Update calculated fields
- /**< The finalize() fammily of members will update
+ /**< The finalize() family of members will update
calculated packet fields: checksums, size fields and so
on. This includes any field, which can be set from
other information in the packet. Each concrete packet
packet */
static ConcretePacket createInsertBefore(Packet const & packet, senf::NoInit_t);
///< Insert uninitialized empty packet before \a packet
- /**< Inserts a completely empty and unitialized packet
+ /**< Inserts a completely empty and uninitialized packet
before \a packet into the header/interpreter chain.
\param[in] packet Packet before which to insert the new
packet */
position. */
safe_data_iterator & operator=(PacketData::iterator i); ///< Assign iterator
- /**< The iteator \a i must be from the container wo which \c
+ /**< The iterator \a i must be from the container which \c
this iterator has been initialized. */
safe_data_iterator & operator=(PacketParserBase const & parser);
///< Assign iterator from parser
This is the container wrapper used for vector parsers. The container wrapper will stay valid
after changing the collection. However the container still depends on the packet and will be
invalidated if the Packet is deallocated or if the packet size is changed from without the
- container wrapper (more precisely, it is invalided if the insertion/deletion happens before
+ container wrapper (more precisely, it is invalidated if the insertion/deletion happens before
the vector in the packet data).
The vector container wrapper provides a complete STL random-access sequence interface.
/** \brief %scheduler specific time source for Utils/Logger framework
- This time source may be used to provide timing information for log messages within the
+ This time source may be used to provide timing information for %log messages within the
Utils/Logger framework. This time source will use Scheduler::eventTime() to provide timing
information.
This class provides the client side policy interface of the socket
abstraction. ClientSocketHandle defines the complete policy interface. It does not implement
any functionality itself however. The following table shows, to which policy members each
- group of ClientSocketHandle members is forwardd. The last collumn shows, on which other
+ group of ClientSocketHandle members is forwarded. The last column shows, on which other
policies this member-group depends <em>in the default policy classes</em>. If you define
your own policy classes, the dependencies are up to you.
\idea Give SocketHandle (and therefore ClientSocketHandle and ServerSocketHandle) a \c
protocol() template member and an additional template arg \c Policies. This arg should be a
- typelist of Poclicy classes which can be accessed. You use protocol<ProtocolClass>() to
+ typelist of policy classes which can be accessed. You use protocol<ProtocolClass>() to
access a protocol class. \c Policies can of course be underspecified or even empty.
\see \ref policy_group \n
disable SO_LINGER to ensure, that v_terminate will not
block. Like the overriden method, this member will ignore
failures and will never throw. It therefore safe to be
- called from a destructor. */ ///\name Abstract Interface Implementation
+ called from a destructor. */
+
+ ///\name Abstract Interface Implementation
//\{
- unsigned available() const;
- bool eof() const;
+ unsigned available() const;
+ bool eof() const;
+
+ //\}
private:
void check_and_unlink() const;
std::string path_;
};
- //\}
}
//-/////////////////////////////////////////////////////////////////////////////////////////////////
description = "numeric id of task to check, -1 for the current task."
default_value = -1 ) );
senf::console::root()
- .add("taskStatus", fty::Commande(static_cast<std::string (*)(std::string const &)>(
+ .add("taskStatus", fty::Command(static_cast<std::string (*)(std::string const &)>(
&taskStatus))
.overloadDoc("Query status by name")
.arg( name = "name",
/** \brief Parse command line options
- The command line otpions in \a argc / \a argv will be parsed, interpreting all node's
+ The command line options in \a argc / \a argv will be parsed, interpreting all node's
relative to \a root as root node.
\related ProgramOptions
/** \brief ConfigBundle source reading command line options
- This cosntructor is used to create aconfig source parsing the given command line options to
+ This constructor is used to create a config source parsing the given command line options to
add to a ConfigBundle.
\related ProgramOptions
#define HH_SENF_Utils_Daemon_Daemon_ 1
// Custom includes
-#include <boost/utility.hpp>
#include <senf/Utils/Logger/SenfLog.hh>
//#include "Daemon.mpp"
for a later fork().
\li <i>Automatic pid file management.</i> The daemon will not be started, if a valid pid
file is found. Stale pid files are automatically removed.
- \li <i>Console log management.</i> It is possible, to redirect standard output and error to
- one or two log files. Messages pertaining to application initialization will be written
- to both the console and the log file whereas later messages will be directed to the log
+ \li <i>Console %log management.</i> It is possible, to redirect standard output and error to
+ one or two %log files. Messages pertaining to application initialization will be written
+ to both the %console and the %log file whereas later messages will be directed to the log
file only.
\li <i>Optional foreground execution.</i> The daemon may be started in the foreground for
- debugging purposes. In this case, the console log file(s) is/are automatically
+ debugging purposes. In this case, the %console %log file(s) is/are automatically
suppressed.
Starting the daemon process proceeds along the following steps:
normally happens from the \c main() function generated by \ref SENF_DAEMON_MAIN().
\li configure() is called. This (virtual) member configures the daemon manager by calling
the Daemon class parameter members.
- \li The log files are opened, \c fork() is called and the pid file is checked and
+ \li The %log files are opened, \c fork() is called and the pid file is checked and
created. The parent (foreground) process keeps running overseeing the daemon process.
\li main() is called. This virtual member may optionally be overridden in the derived
class. Here we assume, main() is not overridden so the default implementation is used.
<tr><td><tt>--no-daemon</tt></td><td>Run in foreground</td></tr>
<tr><td><tt>--console-log=</tt><i>stdout</i>[<tt>,</tt><i>stderr</i>]</td><td>Set the
- console log file(s). If only \a stdout is specified (with no comma), the same log file
+ %console %log file(s). If only \a stdout is specified (with no comma), the same %log file
configuration will be applied to the standard output and error stream. Otherwise each stream
- is assigned it's own log file. If either log file name is empty, the command will not change
- the log file of that stream, the default log file will be used. If the log file name is set
- to 'none', the log file will be disabled.</td></tr>
+ is assigned it's own %log file. If either %log file name is empty, the command will not change
+ the %log file of that stream, the default %log file will be used. If the %log file name is set
+ to 'none', the %log file will be disabled.</td></tr>
<tr><td><tt>--pid-file=</tt><i>pidfile</i></td><td>Set pid file path</td></tr>
The default configure() implementation will use whatever parameters have been set beforehand
as default values. These default values should be set in a derived class configure()
implementation. After setting the default values, the configure() implementation may choose
- to call this default configure() implementation to scan for command line parmeters. The
+ to call this default configure() implementation to scan for command line parameters. The
default configure() implementation does \e not completely parse the command line
- arguments. It just checks, if any of above arguments are present and precesses them. Other
+ arguments. It just checks, if any of above arguments are present and processes them. Other
arguments are completely ignored. The command line parameters should be completely processed
within init().
bool daemon(); ///< \c true, if running as daemon
void consoleLog(std::string const &, StdStream which = Both);
- ///< Configure console log file
- /**< May be called multiple times to set the log file
- for stdout and stderr seperately. Any standard stream
- not assigned to a log file will be redirected to
+ ///< Configure %console %log file
+ /**< May be called multiple times to set the %log file
+ for stdout and stderr separately. Any standard stream
+ not assigned to a %log file will be redirected to
<tt>/dev/null</tt>.
- When running in the foreground, the log files will be
+ When running in the foreground, the %log files will be
ignored. */
void pidFile(std::string const &); ///< Configure pid file
static void exit(unsigned code=0); ///< Terminate daemon with failure
- void logReopen(); ///< Reopen the log files
+ void logReopen(); ///< Reopen the %log files
/**< This is used when rotating the logs. By default,
SIGHUP calls logReopen. */
\endcode
Of course, this only works with objects which explicitly declare, that they take an optional
- senf::NoThrow_t type aprameter.
+ senf::NoThrow_t type parameter.
*/
namespace senf {
functions.
- \section editor_complete Completion suppoprt
+ \section editor_complete Completion support
Completion support is provided by senf::term::bindings::complete(). To use the completer,
you need to implement a completion function and pass it as second argument to
//\{
void gotoChar(unsigned n); ///< Move cursor to position \a n
- void scrollTo(unsigned n); ///< Move positon \n to beginning of display line
+ void scrollTo(unsigned n); ///< Move position \n to beginning of display line
//\}
//\{
void auxDisplay(unsigned line, std::string const & text);
- ///< Display \a text on aux display line \a lilne
+ ///< Display \a text on aux display line \a line
unsigned maxAuxDisplayHeight(); ///< Get maximum height of the aux display area
void clearAuxDisplay(); ///< Clear the aux display area
/** \brief Implement TERMINAL_TYPE option
This telnet handler implements the TERMINAL_TYPE option. The handler automatically requests
- the first terminal type during initialization. Further terminal types may then be reqeusted
+ the first terminal type during initialization. Further terminal types may then be requested
by calling nextTerminalType().
The last received terminal type will be returned by the terminalType() member.
projects / senf.git / commitdiff