agt_slot.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * 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.
 */
 
#if 0 // temp for now so code size not increased.
 
#ifndef _H_agt_slot
#define _H_agt_slot
 
/*  FILE: agt_slot.h
*********************************************************************
*                                                                   *
*            P U R P O S E                                          *
*                                                                   *
*********************************************************************
 
    NETCONF Server Slots handler
 
*********************************************************************
*                                                                   *
*          C H A N G E   H I S T O R Y                              *
*                                                                   *
*********************************************************************
 
date         init     comment
----------------------------------------------------------------------
02-Aug-17    am        Begun;
*/
 
#include "agt.h"
#include "rpc.h"
#include "ses.h"
#include "status_enum.h"
#include "val.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/********************************************************************
*                                                                   *
*            C O N S T A N T S                                      *
*                                                                   *
*********************************************************************/
 
 
/********************************************************************
*                                                                   *
*                T Y P E S                                          *
*                                                                   *
*********************************************************************/
 
/* Typedef of the agt_slot_cb_t callback
*
*
* INPUTS:
*   input == val_value_t to use for write operations
*   output == val_value_t to use for retrieval
*
* OUTPUTS:
*    none
*
* RETURNS:
*    status
*/
typedef status_t
    (*agt_slot_cb_t) (val_value_t *input,
                      val_value_t *output);
 
 
/* header for all the SLOTS records
 * specified by the object template
 */
typedef struct agt_slot_t_ {
    dlq_hdr_t           qhdr;
 
    /* target object node for the callback */
    obj_template_t      *obj;       // back ptr to obj
    const xmlChar       *defpath;
    agt_slot_cb_t       slot_cb;
} agt_slot_t;
 
 
/********************************************************************
*                                                                   *
*           F U N C T I O N S                                       *
*                                                                   *
*********************************************************************/
 
 
/********************************************************************
* FUNCTION agt_slot_new_slot
*
* Create a new SLOT
*
* INPUTS:
*   obj == object template to use
*   slot_cb == callback function to use
*
* RETURNS:
*   pointer to initialized SLOT, or NULL if malloc error
*
*********************************************************************/
extern agt_slot_t *
    agt_slot_new_slot (obj_template_t *obj,
                       const xmlChar *defpath,
                       agt_slot_cb_t slot_cb);
 
 
/********************************************************************
* FUNCTION agt_slot_free_slot
*
* Free a Slot
*
* INPUTS:
*   slot == SLOT to free
* RETURNS:
*   none
*********************************************************************/
extern void
    agt_slot_free_slot (agt_slot_t *slot);
 
 
/********************************************************************
* FUNCTION agt_slot_init
*
* Init the agent slots
*
* RETURNS:
*  status
*********************************************************************/
extern status_t
    agt_slot_init (void);
 
 
/********************************************************************
* FUNCTION agt_slot_cleanup
*
* CLeanup the agent slots
*
*********************************************************************/
extern void
    agt_slot_cleanup (void);
 
 
/********************************************************************
* FUNCTION agt_slot_register_slot
*
* Register a slot into slots Register
*
* INPUTS:
*   obj == object template that represent a slot
*   slot_cbfn  == address of callback function to register
*
* RETURNS:
*   status
*********************************************************************/
extern status_t
    agt_slot_register_slot (const xmlChar *defpath,
                            agt_slot_cb_t slot_cbfn);
 
 
/********************************************************************
* FUNCTION agt_slot_unregister_slot
*
* Unregister all slots inthe Register
*
* INPUTS:
*   obj == object template that represent a slot
*
* RETURNS:
*   none
*********************************************************************/
extern void
    agt_slot_unregister_slot (const xmlChar *defpath);
 
 
/********************************************************************
* FUNCTION agt_slot_invoke_callback
*
* Invoke Callbacks for the specified object template
*
*
* INPUT
*   obj == obj template to use
*   input == input val_value_t for the callback
*   output == output val_value_t for the callback
*
* RETURN
*   status of the operation (usually returned from the callback)
*   NO USER CALLBACK FOUND == NO_ERR
*
********************************************************************/
extern status_t
    agt_slot_invoke_callback (obj_template_t *obj,
                              val_value_t *input,
                              val_value_t *output);
 
 
#ifdef __cplusplus
}  /* end extern 'C' */
#endif
 
#endif      /* _H_agt_slot */
 
 
#endif