/** Constructor from job id.
*
* Initializes the job to obtain information for the given job id.
- * \param[in] jobid The job id of the job this object will
+ * \param[in] jobid The job id of the job this object will
* represent.
* \throws Exception Could not copy the job id.
*/
- Job(const glite::wmsutils::jobid::JobId &);
+ Job(const glite::wmsutils::jobid::JobId &jobid);
/** Destructor.
* Redirect this instance to obtain information about
* different job; connection to the server is preserved, if
* possible.
- * \param[in] jobid New job id.
+ * \param[in] jobid New job id.
* \returns Reference to this object.
* \throws Exception Could not copy the job id.
*/
- Job & operator= (const glite::wmsutils::jobid::JobId &);
+ Job & operator= (const glite::wmsutils::jobid::JobId &jobid);
/*
* Status retrieval bitmasks. Used ORed as Job::status() argument,
*
* Obtain the job status (as JobStatus) from the bookkeeping
* server.
- * \param[in] flags Specify details of the query.
+ * \param[in] flags Specify details of the query.
* \returns Status of the job.
* \throws Exception Could not query the server.
* \see STAT_CLASSADS, STAT_CHILDREN, STAT_CHILDSTAT
*/
- JobStatus status(int) const;
+ JobStatus status(int flags) const;
/** Return all events corresponding to this job
*
* Obtain all events corresponding to the job that are stored
* in the bookkeeping server database. The maximum number of
* returned events can be set by calling setParam().
- * \param[out] events Vector of events (of type Event).
+ * \param[out] events Vector of events (of type Event).
* \throws Exception Could not query the server.
*/
- void log(std::vector<Event> &) const;
+ void log(std::vector<Event> &events) const;
/** Return all events corresponding to this job
*
*
* Obtains the information about last listener that has been
* registered for this job in the bookkeeping server database.
- * \param[in] name Name of the listener.
+ * \param[in] name Name of the listener.
* \returns Hostname and port number of the registered
* listener.
* \throws Exception Could not query the server.
*/
- const std::pair<std::string,uint16_t> queryListener(const std::string & name) const;
+ const std::pair<std::string,uint16_t> queryListener(const std::string &name) const;
/**
* Manipulate LB parameters.
*
* This method sets integer typed parameters for the server connection.
*
- * \param[in] ctx Symbolic name of the parameter to change.
- * \param[in] val New value of the parameter.
+ * \param[in] ctx Symbolic name of the parameter to change.
+ * \param[in] val New value of the parameter.
*/
void setParam(edg_wll_ContextParam ctx, int val);
*
* This method sets string typed parameters for the server connection.
*
- * \param[in] ctx Symbolic name of the parameter to change.
- * \param[in] val New value of the parameter.
+ * \param[in] ctx Symbolic name of the parameter to change.
+ * \param[in] val New value of the parameter.
*/
void setParam(edg_wll_ContextParam ctx, const std::string val);
*
* This method sets timeval typed parameters for the server connection.
*
- * \param[in] ctx Symbolic name of the parameter to change.
- * \param[in] val New value of the parameter.
+ * \param[in] ctx Symbolic name of the parameter to change.
+ * \param[in] val New value of the parameter.
*/
void setParam(edg_wll_ContextParam ctx, const struct timeval &val);
*
* Obtain value of the named integer parameter.
*
- * \param[in] ctx Symbolic name of the paramater to obtain.
+ * \param[in] ctx Symbolic name of the paramater to obtain.
* \return Value of the parameter.
*/
int getParamInt(edg_wll_ContextParam ctx) const;
*
* Obtain value of the named string parameter.
*
- * \param[in] ctx Symbolic name of the paramater to obtain.
+ * \param[in] ctx Symbolic name of the paramater to obtain.
* \return Value of the parameter.
*/
std::string getParamString(edg_wll_ContextParam ctx) const;
*
* Obtain value of the named timeval parameter.
*
- * \param[in] ctx Symbolic name of the paramater to obtain.
+ * \param[in] ctx Symbolic name of the paramater to obtain.
* \return Value of the parameter.
*/
struct timeval getParamTime(edg_wll_ContextParam ctx) const;
/** Constructor for mandatory fields.
*
* Updates all the mandatory fields and names the exception.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
*/
Exception(const std::string& source,
int line_number,
* Updates all the mandatory fields, names the exception and
* adds the original exception's error message to the current
* one.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
- * \param [in] exc Originally raised exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
+ * \param[in] exc Originally raised exception.
*/
Exception(const std::string& source,
int line_number,
/** Constructor for mandatory fields.
*
* Updates all the mandatory fields and names the exception.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
*/
LoggingException(const std::string& source,
int line_number,
* Updates all the mandatory fields, names the exception and
* adds the original exception's error message to the current
* one.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
- * \param [in] exc Originally raised exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
+ * \param[in] exc Originally raised exception.
*/
LoggingException(const std::string& source,
int line_number,
/** Constructor for mandatory fields.
*
* Updates all the mandatory fields and names the exception.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
*/
OSException(const std::string& source,
int line_number,
* Updates all the mandatory fields, names the exception and
* adds the original exception's error message to the current
* one.
- * \param [in] source Source filename where the exception was
- * raised.
- * \param [in] line_number Line in the source that caused the
- * exception.
- * \param [in] method Name of the method that raised the exception.
- * \param [in] code Error code giving the reason for exception.
- * \param [in] exception Error message describing the exception.
- * \param [in] exc Originally raised exception.
+ * \param[in] source Source filename where the exception was raised.
+ * \param[in] line_number Line in the source that caused the exception.
+ * \param[in] method Name of the method that raised the exception.
+ * \param[in] code Error code giving the reason for exception.
+ * \param[in] exception Error message describing the exception.
+ * \param[in] exc Originally raised exception.
*/
OSException(const std::string& source,
int line_number,
/** Create from server host,port pair
* to be used for new notifications, i.e. with Register()
- * \param host IN host
- * \param port IN port
+ * \param[in] host host
+ * \param[in] port port
*/
Notification(const std::string host,const u_int16_t port);
/** Create from NotifId
* to be used for existing notifications, i.e. with Bind()
- * \param notifId IN NotifId
+ * \param[in] notifId NotifId
*/
Notification(const std::string notifId);
/** Add this job to the list.
* Local operation only, Register() has to be called
* to propagate changes to server
- * \param jobId IN JobId
+ * \param[in] jobId JobId
*/
void addJob(const glite::wmsutils::jobid::JobId &jobId);
/** Remove job from the list, local op again.
- * \param jobId IN JobId
+ * \param[in] jobId JobId
*/
void removeJob(const glite::wmsutils::jobid::JobId &jobId);
/** Bind to the existing notification at the server
* i.e. change the receiving local address
- * \param address IN address override
+ * \param[in] address address override
*/
void Bind(const std::string address);
*
* This class is used to construct queries to the L&B database. Each
* query is composed of multiple atomic conditions in the form of
- * <attribute> <predicate> <value>. QueryRecord represents such an
+ * 'attribute' 'predicate' 'value'. QueryRecord represents such an
* atomic condition.
*/
class QueryRecord {
/** Copy constructor
*
* Initializes an exact copy of the object.
- * \param[in] src Original object.
+ * \param[in] src Original object.
*/
- QueryRecord(const QueryRecord &);
+ QueryRecord(const QueryRecord &src);
/** Assignment operator.
*
* Initializes an exact copy of the object.
- * \param[in] src Original object.
+ * \param[in] src Original object.
* \returns Reference to this object.
*/
- QueryRecord& operator=(const QueryRecord &);
+ QueryRecord& operator=(const QueryRecord &src);
/** Constructor for condition on string typed value.
*
* Initializes the object to hold condition on string typed
* attribute value.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value Actual value.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value Actual value.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const std::string &);
+ QueryRecord(const Attr name, const Op op, const std::string &value);
/** Constructor for condition on integer typed value.
*
* Initializes the object to hold condition on integer typed
* attribute value.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value Actual value.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value Actual value.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const int);
+ QueryRecord(const Attr name, const Op op, const int value);
/** Constructor for condition on timeval typed value.
*
* Initializes the object to hold condition on timeval typed
* attribute value.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value Actual value.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value Actual value.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const struct timeval &);
+ QueryRecord(const Attr name, const Op op, const struct timeval &value);
/** Constructor for condition on JobId typed value.
*
* Initializes the object to hold condition on JobId typed
* attribute value.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value Actual value.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value Actual value.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const glite::wmsutils::jobid::JobId&);
+ QueryRecord(const Attr name, const Op op, const glite::wmsutils::jobid::JobId &value);
/* this one is for attr==TIME and particular state */
/** Constructor for condition on timeval typed value.
*
* Initializes the object to hold condition on the time the job
* stays in given state.
- * \param[in] name Name of the attribute.
- * \param[in] state State of thet job.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value Actual value.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] state State of thet job.
+ * \param[in] value Actual value.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const int, const struct timeval &);
+ QueryRecord(const Attr name, const Op op, const int state, const struct timeval &value);
/* constructors for WITHIN operator */
/** Constructor for condition on string typed interval.
*
* Initializes the object to hold condition on string typed
* attribute interval.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value_min Low interval boundary.
- * \param[in] value_max High interval boundary.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value_min Low interval boundary.
+ * \param[in] value_max High interval boundary.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const std::string &, const std::string &);
+ QueryRecord(const Attr name, const Op op, const std::string &value_min, const std::string &value_max);
/** Constructor for condition on integer typed interval.
*
* Initializes the object to hold condition on integer typed
* attribute interval.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value_min Low interval boundary.
- * \param[in] value_max High interval boundary.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value_min Low interval boundary.
+ * \param[in] value_max High interval boundary.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const int, const int);
+ QueryRecord(const Attr name, const Op op, const int value_min, const int value_max);
/** Constructor for condition on timeval typed interval.
*
* Initializes the object to hold condition on timeval typed
* attribute interval.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value_min Low interval boundary.
- * \param[in] value_max High interval boundary.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value_min Low interval boundary.
+ * \param[in] value_max High interval boundary.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const struct timeval &, const struct timeval &);
+ QueryRecord(const Attr name, const Op op, const struct timeval &value_min, const struct timeval &value_max);
/** Constructor for condition on timeval typed interval for
* given state.
*
* Initializes the object to hold condition on the time job
* stayed in given state.
- * \param[in] name Name of the attribute.
- * \param[in] op Symbolic name of the predicate.
- * \param[in] value_min Low interval boundary.
- * \param[in] value_max High interval boundary.
- * \param[in] state State of thet job.
+ * \param[in] name Name of the attribute.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] state State of thet job.
+ * \param[in] value_min Low interval boundary.
+ * \param[in] value_max High interval boundary.
* \throw Exception Invalid value type for given attribute.
*/
- QueryRecord(const Attr, const Op, const int, const struct timeval &, const struct timeval &);
+ QueryRecord(const Attr name, const Op op, const int state, const struct timeval &value_min, const struct timeval &value_max);
/* convenience for user tags */
/** Convenience constructor for condition on user tags.
*
* Initializes the object to hold condition on the value of
* user tag.
- * \param[in] tag Name of the tag.
- * \param[in] op Symbolic namen of the predicate.
- * \param[in] value Value of the tag.
+ * \param[in] tag Name of the tag.
+ * \param[in] op Symbolic name of the predicate.
+ * \param[in] value Value of the tag.
*/
- QueryRecord(const std::string &, const Op, const std::string &);
+ QueryRecord(const std::string &tag, const Op op, const std::string &value);
/** Convenience constructor for condition on user tags.
*
* Initializes the object to hold condition on the value of
* user tag.
- * \param[in] tag Name of the tag.
- * \param[in] op Symbolic namen of the predicate.
- * \param[in] value_min Minimal value of the tag.
- * \param[in] value_max Maximal value of the tag.
+ * \param[in] tag Name of the tag.
+ * \param[in] op Symbolic namen of the predicate.
+ * \param[in] value_min Minimal value of the tag.
+ * \param[in] value_max Maximal value of the tag.
* \throws Exception Predicate is not WITHIN.
*/
- QueryRecord(const std::string &, const Op, const std::string &, const std::string &);
+ QueryRecord(const std::string &tag, const Op op, const std::string &value_min, const std::string &value_max);
/** Destructor.
*
/** Return the string representation of symbolic attribute
* name.
- * \param[in] attr Symbolic attribute name.
+ * \param[in] attr Symbolic attribute name.
* \returns Printable attribute name.
*/
- static const std::string AttrName(const Attr) ;
+ static const std::string AttrName(const Attr attr) ;
protected:
void setQueryEventsLimit(int);
/** Retrieve all events satisfying the query records
- * @param job_cond, event_cond - vectors of conditions to be satisfied
+ * \param[in] job_cond, event_cond vectors of conditions to be satisfied
* by jobs as a whole or particular events, conditions are ANDed
* @param events vector of returned events
*/
/** The same as queryEvents but return only an aggregate.
- * @param job_cond, event_cond - vectors of conditions to be satisfied
+ * \param[in] job_cond, event_cond vectors of conditions to be satisfied
* by jobs as a whole or particular events, conditions are ANDed
- * @param op aggregate operator to apply
- * @param attr attribute to apply the operation to
+ * \param[in] op aggregate operator to apply
+ * \param[in] attr attribute to apply the operation to
*/
std::string queryEventsAggregate(const std::vector<QueryRecord>& job_cond,
const std::vector<QueryRecord>& event_cond,
/** Retrieve all events satisfying the query records
- * @param job_cond, event_cond IN vectors of vectors of job or event conditions,
+ * \param[in] job_cond, event_cond vectors of vectors of job or event conditions,
* respectively. The inner vectors are logically ANDed, the outer are ORed
* (cond1 AND cond2 AND ...) OR (condN AND ...)
- * @param eventList OUT vector of returned events
+ * \param[out] eventList vector of returned events
*/
void queryEvents(const std::vector<std::vector<QueryRecord> >& job_cond,
const std::vector<std::vector<QueryRecord> >& event_cond,
/** Retrieve jobs satisfying the query records, including their states
- * @param query IN vector of Query records that are ANDed to form the query
- * @param jobList OUT vector of returned job id's
+ * \param[in] query vector of Query records that are ANDed to form the query
+ * \param[out] jobList vector of returned job id's
*/
void queryJobs(const std::vector<QueryRecord>& query,
/** Retrieve jobs satisfying the query records, including their states
- * @param query IN vector of Query record vectors that are ORed and ANDed to form the query
- * @param jobList OUT vector of returned job id's
+ * \param[in] query vector of Query record vectors that are ORed and ANDed to form the query
+ * \param[out] jobList vector of returned job id's
*/
void queryJobs(const std::vector<std::vector<QueryRecord> >& query,
queryJobs(const std::vector<std::vector<QueryRecord> >& query) const;
/** Retrieve jobs satisfying the query records, including status information
- * @param query IN vector of Query records that are ANDed to form the query
- * @param flags IN flags
- * @param states OUT vector of returned job states
+ * \param[in] query vector of Query records that are ANDed to form the query
+ * \param[in] flags flags
+ * \param[out] states vector of returned job states
*/
void queryJobStates(const std::vector<QueryRecord>& query,
int flags,
int flags) const;
/** Retrieve jobs satisfying the query records, including status information
- * @param query IN vector of Query records that are anded to form the query
- * @param flags IN flags
- * @param states OUT vector of returned job states
+ * \param[in] query vector of Query records that are anded to form the query
+ * \param[in] flags flags
+ * \param[out] states vector of returned job states
*/
void queryJobStates(const std::vector<std::vector<QueryRecord> >& query,
int flags,
* \a attr \a op \a value eg. time > 87654321.
* \see edg_wll_QueryRec
*
- * \param context IN: context to work with
- * \param job_conditions IN: query conditions (ANDed) on current job status, null (i.e. ATTR_UNDEF) terminated list. NULL means empty list, i.e. always TRUE
- * \param event_conditions: IN: conditions on events, null terminated list, NULL means empty list, i.e. always TRUE
- * \param events OUT: list of matching events
+ * \param[in] context context to work with
+ * \param[in] job_conditions query conditions (ANDed) on current job status, null (i.e. ATTR_UNDEF) terminated list. NULL means empty list, i.e. always TRUE
+ * \param[in] event_conditions conditions on events, null terminated list, NULL means empty list, i.e. always TRUE
+ * \param[out] events list of matching events
*/
int edg_wll_QueryEvents(
edg_wll_Context context,
* Return jobs (and possibly their states) for which an event satisfying the conditions
* exists.
* \see edg_wll_QueryEvents
- * \param context IN: context to work with
- * \param conditions IN: query records (ANDed), null (i.e. EDG_WLL_ATTR_UNDEF) terminated list
- * \param flags IN: additional status fields to retrieve (\see edg_wll_JobStatus)
- * \param jobs OUT: list of job ids. May be NULL.
- * \param states OUT: list of corresponding states (returned only if not NULL)
+ * \param[in] context context to work with
+ * \param[in] conditions query records (ANDed), null (i.e. EDG_WLL_ATTR_UNDEF) terminated list
+ * \param[in] flags additional status fields to retrieve (\see edg_wll_JobStatus)
+ * \param[out] jobs list of job ids. May be NULL.
+ * \param[out] states list of corresponding states (returned only if not NULL)
*/
int edg_wll_QueryJobs(
edg_wll_Context context,
/* starting from bit 10 private flags begins - do not add 1024 and more! */
/** Return status of a single job.
- * \param context IN: context to operate on
- * \param jobid IN: query this job
- * \param flags IN: specifies optional status fields to retrieve,
+ * \param[in] context context to operate on
+ * \param[in] jobid query this job
+ * \param[in] flags specifies optional status fields to retrieve,
* \see EDG_WLL_STAT_CLASSADS, EDG_WLL_STAT_CHILDREN, EDG_WLL_STAT_CHILDSTAT
- * \param status OUT: status
+ * \param[out] status status
*/
int edg_wll_JobStatus(
/**
* Query LBProxy and use plain communication
- * \param context IN: context to operate on
- * \param jobid IN: query this job
- * \param flags IN: specifies optional status fields to retrieve,
+ * \param[in] context context to operate on
+ * \param[in] jobid query this job
+ * \param[in] flags specifies optional status fields to retrieve,
* \see EDG_WLL_STAT_CLASSADS, EDG_WLL_STAT_CHILDREN, EDG_WLL_STAT_CHILDSTAT
- * \param status OUT: the status of the job
+ * \param[out] status the status of the job
*/
int edg_wll_JobStatusProxy(
edg_wll_Context context,
/**
* Return all events related to a single job.
* Convenience wrapper around edg_wll_Query()
- * \param context IN: context to work with
- * \param jobId IN: job to query
- * \param events OUT: list of events
+ * \param[in] context context to work with
+ * \param[in] jobId job to query
+ * \param[out] events list of events
*/
int edg_wll_JobLog(
/**
* All current user's jobs.
- * \param context IN: context to work with
- * \param jobs OUT: list of the user's jobs
- * \param states OUT: list of the jobs' states
+ * \param[in] context context to work with
+ * \param[out] jobs list of the user's jobs
+ * \param[out] states list of the jobs' states
*/
int edg_wll_UserJobs(
edg_wll_Context context,
/**
* Server supported indexed attributes
* \see DataGrid-01-TEN-0125
- * \param context IN: context to work with
- * \param attrs OUT: configured indices (each index is an UNDEF-terminated
+ * \param[in] context context to work with
+ * \param[out] attrs configured indices (each index is an UNDEF-terminated
* array of QueryRec's from which only attr (and attr_id
* eventually) are meaningful
*/
* Retrieve limit on query result size (no. of events or jobs).
* FIXME: not implemented.
* \see DataGrid-01-TEN-0125
- * \param context IN: context to work with
- * \param limit OUT: server imposed limit
+ * \param[in] context context to work with
+ * \param[out] limit server imposed limit
*/
int edg_wll_GetServerLimit(
edg_wll_Context context,
/**
* UI port for the job
- * \param context IN: context to work with
- * \param jobId IN: job to query
- * \param name IN: name of the UI-port
- * \param host OUT: hostname of port
- * \param port OUT: port number
+ * \param[in] context context to work with
+ * \param[in] jobId job to query
+ * \param[in] name name of the UI-port
+ * \param[out] host hostname of port
+ * \param[out] port port number
*/
int edg_wll_QueryListener(
edg_wll_Context context,
/**
* Ask LB Proxy server for sequence number
- * \param context IN: context to work with
- * \param jobId IN: job to query
- * \param code OUT: sequence code
+ * \param[in] context context to work with
+ * \param[in] jobId job to query
+ * \param[out] code sequence code
*/
/** Allocate an initialize a new context object.
- * \param context OUT returned context
+ * \param[out] context returned context
* \return 0 on success, ENOMEM if malloc() fails
*/
int edg_wll_InitContext(edg_wll_Context *context);
/** Destroy and free context object.
* Also performs necessary cleanup (closing connections etc.)
- * \param context IN context to free
+ * \param[in] context context to free
*/
void edg_wll_FreeContext(edg_wll_Context context);
/** Set a context parameter.
- * \param context INOUT context to work with
- * \param param IN parameter to set
- * \param ... IN value to set (if NULL or 0, default is used)
+ * \param[in,out] context context to work with
+ * \param[in] param parameter to set
+ * \param[in] ... value to set (if NULL or 0, default is used)
* \retval 0 success
* \retval EINVAL param is not a valid parameter, or invalid value
*/
struct timeval; /* XXX: gcc, shut up! */
/** Set a context parameter of type int.
- * \param ctx INOUT context to work with
- * \param param IN parameter to set
- * \param val IN value to set
- * \retval 0 success
- * \retval EINVAL param is not a valid parameter, or invalid value
+ * \param[in,out] ctx context to work with
+ * \param[in] param parameter to set
+ * \param[in] val value to set
+ * \retval 0 success
+ * \retval EINVAL param is not a valid parameter, or invalid value
*/
int edg_wll_SetParamInt(edg_wll_Context ctx,edg_wll_ContextParam param,int val);
/** Set a context parameter of type string.
- * \param ctx INOUT context to work with
- * \param param IN parameter to set
- * \param val In value to set (if NULL, default is used)
- * \retval 0 success
- * \retval EINVAL param is not a valid parameter, or invalid value
+ * \param[in,out] ctx context to work with
+ * \param[in] param parameter to set
+ * \param[in] val value to set (if NULL, default is used)
+ * \retval 0 success
+ * \retval EINVAL param is not a valid parameter, or invalid value
*/
int edg_wll_SetParamString(edg_wll_Context ctx,edg_wll_ContextParam param,const char *val);
/** Set a context parameter of type timeval.
- * \param ctx INOUT context to work with
- * \param param IN parameter to set
- * \param val IN value to set (if NULL, default is used)
- * \retval 0 success
- * \retval EINVAL param is not a valid parameter, or invalid value
+ * \param[in,out] ctx context to work with
+ * \param[in] param parameter to set
+ * \param[in] val value to set (if NULL, default is used)
+ * \retval 0 success
+ * \retval EINVAL param is not a valid parameter, or invalid value
*/
int edg_wll_SetParamTime(edg_wll_Context ctx,edg_wll_ContextParam param,const struct timeval *val);
/** Get current parameter value.
- * \param context INOUT context to work with
- * \param param IN parameter to retrieve
- * \param ... OUT pointer to output variable
+ * \param[in,out] context context to work with
+ * \param[in] param parameter to retrieve
+ * \param[out] ... pointer to output variable
* \retval 0 success
* \retval EINVAL param is not a valid parameter
*/
/**
* Retrieve error details on recent API call
- * \param context IN: context to work with
- * \param errText OUT: standard error text
+ * \param[in] context context to work with
+ * \param[out] errText standard error text
* (may be NULL - no text returned)
- * \param errDesc OUT: additional error description
+ * \param[out] errDesc additional error description
* (may be NULL - no text returned)
* \return Error code of the recent error
*/
} edg_wll_EventCode;
/**
- * \fn edg_wll_EventCode edg_wll_StringToEvent(char *name)
- * \param name a string event name (e.g. "JobTransfer")
+ * \fn edg_wll_EventCode edg_wll_StringToEvent(const char *name)
+ * \param[in] name a string event name (e.g. "JobTransfer")
* \return corresponding numeric code (edg_wll_EventCode)
* \brief convert a string event name to the corresponding numeric code
*/
-extern edg_wll_EventCode edg_wll_StringToEvent(char *);
+extern edg_wll_EventCode edg_wll_StringToEvent(const char *name);
/**
* \fn char *edg_wll_EventToString(edg_wll_EventCode event)
- * \param event an event numeric code (edg_wll_EventCode)
+ * \param[in] event an event numeric code (edg_wll_EventCode)
* \return corresponding string (e.g. "JobTransfer")
* \brief convert an event numeric code to the corresponding string
*/
-extern char *edg_wll_EventToString(edg_wll_EventCode);
+extern char *edg_wll_EventToString(edg_wll_EventCode event);
/**
} edg_wll_KeyNameCode;
/**
- * \fn edg_wll_KeyNameCode edg_wll_StringToKeyName(char *name)
- * \param name a string ULM key name (e.g. "DG.JOB.TRANSFER.DEST")
+ * \fn edg_wll_KeyNameCode edg_wll_StringToKeyName(const char *name)
+ * \param[in] name a string ULM key name (e.g. "DG.JOB.TRANSFER.DEST")
* \return corresponding numeric code (edg_wll_KeyNameCode)
* \brief convert a string ULM key name to the corresponding numeric code
*/
-extern edg_wll_KeyNameCode edg_wll_StringToKeyName(char *);
+extern edg_wll_KeyNameCode edg_wll_StringToKeyName(const char *name);
/**
* \fn char *edg_wll_KeyNameToString(edg_wll_KeyNameCode key)
- * \param key a ULM key name numeric code (edg_wll_KeyNameCode)
+ * \param[in] key a ULM key name numeric code (edg_wll_KeyNameCode)
* \return corresponding string (e.g. "DG.JOB.TRANSFER.DEST")
* \brief convert a ULM key name numeric code to the corresponding string
*/
-extern char *edg_wll_KeyNameToString(edg_wll_KeyNameCode);
+extern char *edg_wll_KeyNameToString(edg_wll_KeyNameCode key);
/**
# function StringTo:
gen qq{
/**
- * \\fn $enum edg_wll_StringTo${c}(char *name);
- * \\param name a string representing $fn code (e.g. \"${$f->{codes}}[1]->{name}\")
+ * \\fn $enum edg_wll_StringTo${c}(const char *name);
+ * \\param[in] name a string representing $fn code (e.g. \"${$f->{codes}}[1]->{name}\")
* \\return corresponding numeric code ($enum)
* \\brief converts a string $fn code to corresponding numeric code
*/
-extern $enum edg_wll_StringTo${c}(char *name);
+extern $enum edg_wll_StringTo${c}(const char *name);
};
# function ToString:
gen qq{
/**
* \\fn char *edg_wll\_${c}ToString($enum code);
- * \\param code a $fn numeric code ($enum)
+ * \\param[in] code a $fn numeric code ($enum)
* \\return corresponding string (e.g. \"${$f->{codes}}[1]->{name}\")
* \\brief converts a $fn numeric code to corresponding string
*/
# function StringTo:
gen qq{
/**
- * \\fn $enum edg_wll_StringTo${c}(char *name);
- * \\param name a string representing $t $fn code (e.g. \"${$f->{codes}}[1]->{name}\")
+ * \\fn $enum edg_wll_StringTo${c}(const char *name);
+ * \\param[in] name a string representing $t $fn code (e.g. \"${$f->{codes}}[1]->{name}\")
* \\return corresponding numeric code ($enum)
* \\brief converts a string $t $fn code to corresponding numeric code
*/
-extern $enum edg_wll_StringTo${c}(char *name);
+extern $enum edg_wll_StringTo${c}(const char *name);
};
# function ToString:
gen qq{
/**
* \\fn char *edg_wll\_${c}ToString($enum code);
- * \\param code a $t $fn numeric code ($enum)
+ * \\param[in] code a $t $fn numeric code ($enum)
* \\return corresponding string (e.g. \"${$f->{codes}}[1]->{name}\")
* \\brief converts a $t $fn numeric code to corresponding string
*/
/**
* Free the contents of event structure
- * \param event IN structure to be freed
+ * \param[in] event structure to be freed
* \warning As event structures are likely to be allocated in arrays,
* the structure itself is not freed.
* Its the responsibility of the caller to call free(event)
/** Register for receiving notifications.
* Connects to the server specified by EDG_WLL_NOTIF_SERVER context parameter
* (temporary workaround, should be resolved by registry in future).
- * \param context INOUT: context to work with
- * \param conditions IN: the same conditions as for \ref edg_wll_QueryJobsExt.
+ * \param[in,out] context context to work with
+ * \param[in] conditions the same conditions as for \ref edg_wll_QueryJobsExt.
* currently one or more JOBID's are required.
* Only a single occurence of a specific attribute is allowed
* among ANDed conditions (due to the ability to modify them
* further).
- * \param fd IN: = -1 create or reuse the default listening socket (one per context)
+ * \param[in] fd = -1 create or reuse the default listening socket (one per context)
* >= 0 non-default listening socket
- * \param address_override IN: if not NULL, use this address instead of extracting it
+ * \param[in] address_override if not NULL, use this address instead of extracting it
* from the connection (useful when multiple interfaces are present,
* circumventing NAT problems etc.)
- * \param valid IN: until when the registration is valid (NULL means no interest in
- * \param id_out OUT: returened NotifId
+ * \param[in] valid until when the registration is valid (NULL means no interest in
+ * \param[out] id_out returened NotifId
* the value
* \retval 0 OK
* \retval EINVAL restrictions on conditions are not met
/** Change the receiving local address.
* Report the new address to the server.
*
- * \param context INOUT: context to work with
- * \param id IN: notification ID you are binding to
- * \param fd IN; same as for \ref edg_wll_NotifNew
- * \param address_override IN: same as for \ref edg_wll_NotifNew
- * \param valid IN: same as for \ref edg_wll_NotifNew
+ * \param[in,out] context context to work with
+ * \param[in] id notification ID you are binding to
+ * \param[in] fd same as for \ref edg_wll_NotifNew
+ * \param[in] address_override same as for \ref edg_wll_NotifNew
+ * \param[in] valid same as for \ref edg_wll_NotifNew
*/
int edg_wll_NotifBind(
* of uniqueness the original conditions must have contained only a single
* OR-ed row of conditions on the attributes infolved in the change.
*
- * \param context INOUT: context to work with
- * \param id IN: notification ID you are working with
- * \param conditions IN: same as for \ref edg_wll_NotifNew
- * \param op IN: action to be taken on existing conditions,
+ * \param[in,out] context context to work with
+ * \param[in] id notification ID you are working with
+ * \param[in] conditions same as for \ref edg_wll_NotifNew
+ * \param[in] op action to be taken on existing conditions,
* \ref edg_wll_NotifChangeOp
*/
int edg_wll_NotifChange(
);
/** Refresh the registration, i.e. extend its validity period.
- * \param context INOUT: context to work with
- * \param id IN: notification ID you are working with
- * \param valid IN: until when the registration is valid (NULL means no interest in
+ * \param[in,out] context context to work with
+ * \param[in] id notification ID you are working with
+ * \param[in] valid until when the registration is valid (NULL means no interest in
* the value
*/
/** Drop the registration.
* Server is instructed not to send notifications anymore, pending ones
* are discarded, listening socket is closed, and allocated memory freed.
- * \param context INOUT: context to work with
- * \param id IN: notification ID you are working with
+ * \param[in,out] context context to work with
+ * \param[in] id notification ID you are working with
*/
int edg_wll_NotifDrop(
/** Receive notification.
* The first incoming notification is returned.
- * \param context INOUT: context to work with
- * \param fd IN: receive on this socket (-1 means the default for the context)
- * \param timeout IN: wait atmost this time long. (0,0) means polling, NULL waiting
+ * \param[in,out] context context to work with
+ * \param[in] fd receive on this socket (-1 means the default for the context)
+ * \param[in] timeout wait atmost this time long. (0,0) means polling, NULL waiting
* indefinitely
- * \param state_out OUT: returned JobStatus
- * \param id_out OUT: returned NotifId
+ * \param[out] state_out returned JobStatus
+ * \param[out] id_out returned NotifId
* \retval 0 notification received, state_out contains the current job state
* \retval EAGAIN no notification available, timeout occured
*/
* there may be some data cached so calling \ref edg_wll_NotifReceive
* may return notifications immediately.
*
- * \param context INOUT: context to work with
+ * \param[in,out] context context to work with
* \retval >=0 socket descriptor
* \retval -1 error, details set in context
*/
/** Close the default local listening socket.
* Useful to force following \ref edg_wll_NotifBind to open
* a new one.
- * \param context INOUT: context to work with
+ * \param[in,out] context context to work with
*/
int edg_wll_NotifCloseFd(
/**
* Create a Job ID.
- * \param server IN: notification server hostname
- * \param port IN: port of the notification server
- * \param notifid OUT: newly created NotifId
+ * \param[in] server notification server hostname
+ * \param[in] port port of the notification server
+ * \param[out] notifid newly created NotifId
* \retval 0 for success
* \retval EINVAL invalid notification server
* \retval ENOMEM if memory allocation fails
/**
* Free the NotifId structure
- * \param notifid IN: for dealocation
+ * \param[in] notifid for dealocation
*/
void edg_wll_NotifIdFree(edg_wll_NotifId notifid);
/** Parse the NotifId string and creates NotifId structure
- * \param notifidstr IN: string representation of NotifId
- * \param notifid OUT: parsed NotifId
+ * \param[in] notifidstr string representation of NotifId
+ * \param[out] notifid parsed NotifId
* \retval 0 for success
* \retval EINVAL notifidstr can't be parsed
* \retval ENOMEM if memory allocation fails
int edg_wll_NotifIdParse(const char *notifidstr, edg_wll_NotifId *notifid);
/** Unparse the NotifId (produce the string form of NotifId).
- * \param notifid IN: NotifId to be converted to string
+ * \param[in] notifid NotifId to be converted to string
* \return allocated string which represents the NotifId
*/
char* edg_wll_NotifIdUnparse(const edg_wll_NotifId notifid);
/**
* Extract notification server address (address:port)
- * \param notifid IN: NotifId from which the address should be extracted
- * \param srvName INOUT: pointer where to return server name
- * \param srvPort INOUT: pointer where to return server port
+ * \param[in] notifid NotifId from which the address should be extracted
+ * \param[in,out] srvName pointer where to return server name
+ * \param[in,out] srvPort pointer where to return server port
*/
void edg_wll_NotifIdGetServerParts(const edg_wll_NotifId notifid, char **srvName, unsigned int *srvPort);
/**
* Extract unique string
- * \param notifid IN: NotifId
+ * \param[in] notifid NotifId
* \retval pointer to allocated unique string representing jobid
* \retval NULL if jobid is 0 or memory allocation fails
*/
/**
* Recreate a NotifId by a new unique string
- * \param unique IN: string which represent created notifid (if NULL then new
+ * \param[in] unique string which represent created notifid (if NULL then new
* one is created)
- * \param notifid INOUT: newly created NotifId
+ * \param[in,out] notifid newly created NotifId
* \retval 0 success
* \retval EINVAL invalid NotifId
* \retval ENOMEM if memory allocation fails
my $a = "(edg_wll_Context context";
my $b = "(context,EDG_WLL_EVENT_$tu,EDG_WLL_FORMAT_$tu";
my $doc = qq{
- * \\param context\tcontext to work with,
+ * \\param[in,out] context\tcontext to work with,
};
selectType $event $t;
for ($event->getFieldsOrdered) {
my $fc = $f->getComment;
$a = $a . ", $ft $fn";
$b = $b . ", $fn";
- $doc = $doc . " * \\param $fn\t$fc\n";
+ $doc = $doc . " * \\param[in] $fn\t$fc\n";
}
$a = $a . ")";
$b = $b . ")";
my $e = $doc;
$c =~ s/, $ftreg $fn//g;
$d =~ s/$fn/"$code"/g;
- $e =~ s/ \* \\param $fn\t$fc\n//g;
+# FIXME: this documentation line in $e doesn't delete!!
+ $e =~ s/ \* \\param\[in\] $fn\t$fc\n//g;
gen qq{
/**
* \\fn int edg_wll_Log$t$code$c;
/**
* Formats a logging message and sends it asynchronously to local-logger
* \brief generic asynchronous logging function
- * \param context INOUT context to work with,
- * \param event IN type of the event,
- * \param fmt IN printf()-like format string,
- * \param ... IN event specific values/data according to fmt,
+ * \param[in,out] context context to work with,
+ * \param[in] event type of the event,
+ * \param[in] fmt printf()-like format string,
+ * \param[in] ... event specific values/data according to fmt,
* \retval 0 successful completition,
* \retval EINVAL bad jobId, unknown event code, or the format string together with the remaining arguments does not form a valid event,
* \retval ENOSPC L&B infrastructure failed to accept the event due to lack of disk space etc.,
/**
* Formats a logging message and sends it synchronously to local-logger
* \brief generic synchronous logging function
- * \param context INOUT context to work with,
- * \param event IN type of the event,
- * \param fmt IN printf()-like format string,
- * \param ... IN event specific values/data according to fmt,
+ * \param[in,out] context context to work with,
+ * \param[in] event type of the event,
+ * \param[in] fmt printf()-like format string,
+ * \param[in] ... event specific values/data according to fmt,
* \retval 0 successful completition,
* \retval EINVAL bad jobId, unknown event code, or the format string together with the remaining arguments does not form a valid event,
* \retval ENOSPC L&B infrastructure failed to accept the event due to lack of disk space etc.,
* Instructs interlogger to to deliver all pending events related to current job
* \brief flush events from interlogger
* \note sort of status query more than a command
- * \param context INOUT context to work with,
- * \param timeout INOUT wait at most this much time for completition, remaining time on return,
- * \retval 0 successful completition,
+ * \param[in,out] context context to work with,
+ * \param[in,out] timeout wait at most this much time for completition, remaining time on return,
+ * \retval 0 successful completition,
* \retval EDG_WLL_ERROR_INTERLOG_TIMEOUT the inter-logger did not respond within the timeout,
* \retval EDG_WLL_ERROR_INTERLOG_CONLOST inter-logger lost connection to one or more servers,
* \retval EDG_WLL_ERROR_INTERLOG_AGAIN not all pending events were delivered within the timeout.
/**
* Set a current job for given context.
* \note Should be called before any logging call.
- * \param context INOUT context to work with
- * \param job IN further logging calls are related to this job
- * \param code IN sequence code as obtained from previous component
- * \param flags IN flags on code handling (\see API documentation)
+ * \param[in,out] context context to work with
+ * \param[in] job further logging calls are related to this job
+ * \param[in] code sequence code as obtained from previous component
+ * \param[in] flags flags on code handling (\see API documentation)
*/
extern int edg_wll_SetLoggingJob(
edg_wll_Context context,
* Partitionable jobs should set num_subjobs=0 initially,
* and re-register when number of subjobs becomes known.
*
- * \param context INOUT context to work with
- * \param job IN jobId
- * \param type IN EDG_WLL_JOB_SIMPLE, EDG_WLL_JOB_DAG, or EDG_WLL_JOB_PARTITIONABLE
- * \param jdl IN user-specified JDL
- * \param ns IN network server contact
- * \param num_subjobs IN number of subjobs to create
- * \param seed IN seed used for subjob id's generator.
+ * \param[in,out] context context to work with
+ * \param[in] job jobId
+ * \param[in] type EDG_WLL_JOB_SIMPLE, EDG_WLL_JOB_DAG, or EDG_WLL_JOB_PARTITIONABLE
+ * \param[in] jdl user-specified JDL
+ * \param[in] ns network server contact
+ * \param[in] num_subjobs number of subjobs to create
+ * \param[in] seed seed used for subjob id's generator.
* Use non-NULL value to be able to regenerate the set of jobid's
- * \param subjobs OUT returned subjob id's
+ * \param[out] subjobs returned subjob id's
*/
/* backward compatibility */
* Register subjobs in a batch.
* Mainly used to provide JDL's of individual subjobs in a more efficient
* way than logging them one by one.
- * \param context INOUT context to work with
- * \param parent IN parent's jobId
- * \param jdls IN array of JDL's
- * \param ns IN network server contact
- * \param subjobs OUT array of jobid's in the same order
+ * \param[in,out] context context to work with
+ * \param[in] parent parent's jobId
+ * \param[in] jdls array of JDL's
+ * \param[in] ns network server contact
+ * \param[out] subjobs array of jobid's in the same order
*/
extern int edg_wll_RegisterSubjobs(
/**
* Change ACL for given job.
- * \param context INOUT context to work with
- * \param job IN jobId
- * \param user_id IN specification of user's credential
- * \param user_id_type IN type of user_id,
+ * \param[in,out] context context to work with
+ * \param[in] job jobId
+ * \param[in] user_id specification of user's credential
+ * \param[in] user_id_type type of user_id,
* for EDG_WLL_USER_SUBJECT the user_id parameter is expected to be user's subject name
* for EDG_WLL_USER_VOMS_GROUP the user_id is expected to be of the form VO:group specifying required group membersip as managed by VOMS
- * \param permission ACL permission to change
- * \param permission_type type of given permission (allow or deny operation)
- * \param operation operation to perform with ACL (add or remove record)
+ * \param[in] permission ACL permission to change
+ * \param[in] permission_type type of given permission (allow or deny operation)
+ * \param[in] operation operation to perform with ACL (add or remove record)
*/
extern int edg_wll_ChangeACL(
#endif
/** Count the number of jobs which entered the specified state.
- * \param group IN: group of jobs of interest, eg. DESTINATION = something
+ * \param[in] group group of jobs of interest, eg. DESTINATION = something
* (XXX: this is the only query supported right now)
- * \param major IN: major code of the state of interest
- * \param minor IN: minor state code, eg. DONE_FAILED
- * \param from,to INOUT: on input - requested interval of interest
+ * \param[in] major major code of the state of interest
+ * \param[in] minor minor state code, eg. DONE_FAILED
+ * \param[in,out] from,to on input - requested interval of interest
* on output - when the data were available
- * \param rate OUT: average rate per second in which the jobs enter this state
- * \param res_from, res_to: time resolution of the data (seconds)
+ * \param[out] rate average rate per second in which the jobs enter this state
+ * \param[out] res_from,res_to time resolution of the data (seconds)
*/
int edg_wll_StateRate(
git://scientific.zcu.cz / jra1mw.git / commitdiff