source: tmcsimulator/branches/fep_client_cpp/fep_print.cpp @ 69

#include "fep.h"
#include "hexdump.c"

/* The following get_*_text functions are helper functions used to
   get enum type names as strings */
const char* get_polltype_text(enum polltype ptype)
{
        switch(ptype)
        {
                case POLL:
                        return "POLL";
                case COMMAND:
                        return "COMMAND";
                case TIMESYNC:
                        return "TIMESYNC";
                default:
                        return "UNKNOWN";
        }       
}

const char* get_status_text(enum errorstatus estat)
{
        switch(estat)
        { case FEP_OK: 
                        return "FEP_OK";
                case FEP_OUTOFRANGE: 
                        return "FEP_OUTOFRANGE";
                case FEP_BADHANDLE: 
                        return "FEP_BADHANDLE";
                case FEP_NOREPLY: 
                        return "FEP_NOREPLY";
                case FEP_SCHBUSY: 
                        return "FEP_SCHBUSY";
                case FEP_LINEBUSY: 
                        return "FEP_LINEBUSY";
                case FEP_REPORTBUSY: 
                        return "FEP_REPORTBUSY";
                case FEP_NOREPORT: 
                        return "FEP_NOREPORT";
                case FEP_NOMEMORY: 
                        return "FEP_NOMEMORY";
                case FEP_BADTIME: 
                        return "FEP_BADTIME";
                case FEP_BADTIMESYNCH: 
                        return "FEP_BADTIMESYNCH";
                case FEP_BADKIND: 
                        return "FEP_BADKIND";
                case FEP_BADCONNECT: 
                        return "FEP_BADCONNECT";
                case FEP_NOAUTHORITY: 
                        return "FEP_NOAUTHORITY";
                default: 
                        return "UNKNOWN";
        }
} 

const char* get_answererror_text(enum answererror err)
{
        switch(err)
        {
                case ERR_BSCF_ERR:
                        return "ERR_BSCF_ERR";
                case ERR_NONE:
                        return "ERR_NONE";
                case ERR_MSG_LEN:
                        return "ERR_MSG_LEN";
                case ERR_MSG_HDR:
                        return "ERR_MSG_HDR";
                case ERR_MSG_CHKSUM:
                        return "ERR_MSG_CHKSUM";
                case ERR_MSG_TRAILER:
                        return "ERR_MSG_TRAILER";
                default:
                        return "UNKNOWN";
        }
}

const char * get_pollingfsm_text(enum Polling_FSM_States state)
{
        switch(state)
        {
                case INITSTATE:
                        return "INITSTATE";
                case WRALARMSTATE:
                        return "WRALARMSTATE";
                case CLRSTATE:
                        return "CLRSTATE";
                case RTSONSTATE:
                        return "RTSONSTATE";
                case CTSSTATE:
                        return "CTSSTATE";
                case WRITESTATE:
                        return "WRITESTATE";
                case RTSOFFSTATE:
                        return "RTSOFFSTATE";
                case RDALARMSTATE:
                        return "RDALARMSTATE";
                case RDSTATE:
                        return "RDSTATE";
                case DONESTATE:
                        return "DONESTATE";
                default:
                        return "UNKNOWN";
        }
}

const char *get_replystatus_text(enum replystatus status)
{
        switch(status)
        {
                case FAILURE:
                        return "FAILURE";
                case DONE:
                        return "DONE";
                case UNUSED:
                        return "UNUSED";
                default:
                        return "UNKNOWN";
        }
}

const char *get_replykind_text(enum replykind kind)
{
        switch(kind)
        {
                case POLLREPLY:
                        return "POLLREPLY";
                case SCHEDNEW:
                        return "SCHEDNEW";
                case SCHEDDONE:
                        return "SCHEDDONE";
                default:
                        return "UNKNOWN";
        }
}

/* The following functions are used to print fep_reply, reply_ret structs and associated structs */
void print_fep_pollerror(fep_pollerror pollerror)
{
        printf("\t\t\t\t\t\tpoll error:\n");
        printf("\t\t\t\t\t\tanswererror msgerror:\t%s\n", get_answererror_text(pollerror.msgerror));
        printf("\t\t\t\t\t\tPolling_FSM_States state:\t%s\n", get_pollingfsm_text(pollerror.state));
        printf("\t\t\t\t\t\t\tint perrno:\t%d\n", pollerror.perrno);
        printf("\t\t\t\t\t\t\tint termination:\t%d\n", pollerror.termination);
        printf("\t\t\t\t\t\t\tint count:\t%d\n", pollerror.count);
}

void print_fep_answer_info(fep_answer_info info)
{
        printf("\t\t\t\t\tfep_answer_info:\n");
        printf("\t\t\t\t\t\tlong poll_time:\t%ld\n", info.poll_time);
        printf("\t\t\t\t\t\treplystatus status:\t%s\n", get_replystatus_text(info.status));
        printf("\t\t\t\t\t\tint poll_user_info1:\t%d\n", info.poll_user_info1);
        printf("\t\t\t\t\t\tint poll_user_info2:\t%d\n", info.poll_user_info2);
        printf("\t\t\t\t\t\tint retries:\t%d\n", info.retries);
        printf("\t\t\t\t\t\tint poll_error_count:\t%d\n", info.poll_error_count);
        for(int i = 0; i < info.poll_error_count; i++)
        {
                print_fep_pollerror(*info.pollerror);
        }
}

void print_fep_answer_short_msg(fep_answer_short_msg msg)
{
        printf("\t\t\t\t\tfep_answer_short:\n");
        printf("\t\t\t\t\t\tint message_len:\t%d\n", msg.message_len);
        printf("\t\t\t\t\t\tmessage:\t");
        for(int i = 0; i < msg.message_len; i++)
        {
                printf("%04x ", msg.message[i]);
        }
        printf("\n");
}

void print_fep_shortanswer(fep_shortanswer answer)
{
        printf("\t\t\t\tfep_shortanswer:\n");
        print_fep_answer_info(answer.info);
        print_fep_answer_short_msg(answer.msg);
}

void print_fep_shortanswer_list(fep_shortanswer_list answer_list)
{
        printf("\t\t\tfep_shortanswer_list:\n");
        printf("\t\t\t\tcount:\t%d\n", answer_list.count);
        for(int i = 0; i < answer_list.count; i++)
        {       
                print_fep_shortanswer(answer_list.answers[i]);  
        }
}

void print_fep_answer_list(fep_answer_list answers)
{
        printf("\t\tfep_answer_list:\n");
        printf("\t\t\tint size:\t%d\n", answers.size);
        print_fep_shortanswer_list(answers.fep_answer_list_u.shortp);
}

void print_fep_reply(fep_reply reply)
{
        printf("\tfep_reply: \n");
        printf("\t\tint reply:\t%d\n", reply.reply);
        printf("\t\tint schedule:\t%d\n", reply.schedule); 
        printf("\t\tint lineinfo:\t%d\n", reply.lineinfo);
        printf("\t\tpolltype kind:\t%s\n", get_polltype_text(reply.kind));
        printf("\t\treplykind flag:\t%s\n", get_replykind_text(reply.flag));
        printf("\t\tint schedule_sequence:\t%d\n", reply.schedule_sequence);
        printf("\t\tint global_sequence:\t%d\n", reply.global_sequence);
        printf("\t\tlong schedule_time:\t%ld\n", reply.schedule_time);
        printf("\t\tint user_info1:\t%d\n", reply.user_info1);
        printf("\t\tint user_info2:\t%d\n", reply.user_info2);
        print_fep_answer_list(reply.answers);
}

/* Dumps the ATMS's response to RPC Call (struct reply_ret) */
void print_reply_ret(reply_ret response) {
        printf("reply_ret:\n");
        // Print response status
        printf("\tfep_status: %s\n", get_status_text(response.status));
        print_fep_reply(response.reply_ret_u.info);
}