Managing and handling multiple abstract data types in C with type safety?

Question

I have several hardware signals that get toggled based on properties relevant to scenarios in which respective signals could be toggled. The problem is that signals and the properties that define scenarios, all three could change. I am forced to think in terms of a modular framework based design in which there is SignalManager that handles signal creation and there is a SignalPropertiesData with its SignalPropertiesDataManager that associate certain SignalScenario structure and all this is created specifically for any type of signal by the SignalManager. I wish to follow the public interface, private data in the C programming paradigm.

My dilemma is C in general when it comes to type safety and this kind of problem, the only solution is to lose type safety and use 'void' for any and all types of data. Can you point me to any code or component in the vast opensource sea, which can serve as a right reference for this problem.

signal_manager.h:

#ifdef _SIGNAL_MANAGER_H
#define _SIGNAL_MANAGER_H

int createSignal(SignalDescPtr signalDescPtr);

int destroySignal();

typedef struct SignalDesc* SignalDescPtr;

#endif

signal_manager.c:

#include "signal_manager.h"

typedef struct {
  char* signalName;
  unsigned int signalId;
  SignalPropertiesDataPtr signalProperties;
} SignalDesc;

signal_properties_data.h:

#ifdef _SIGNAL_PROPERTIES_DATA
#define _SIGNAL_PROPERTIES_DATA

typedef enum {
  SIGNAL_DATA_INT_TYPE,
  SIGNAL_DATA_UNSIGNED_INT_TYPE,
  SIGNAL_DATA_FLOAT_TYPE,
     :
  SIGNAL_DATA_UNSPECIFIED_BASIC_TYPE
} eSignalBasicType;

typedef enum {
  SIGNAL_DATA_LIST_ARRAY_TYPE,
  SIGNAL_DATA_LIST_ADT_TYPE,
   :
   :
  SIGNAL_DATA_LIST_UNSPECIFIED_TYPE
} eSignalComplexType

typdef  union {
  eSignalBasicType signalBasicType;
  eSignalComplexType signalComplexType;
} eSignalType;

typedef struct {
  eSignalType signalType;
  unsigned int signalDataLen;
} SignalDataValueType;    

typedef SignalPropertiesData* SignalPropertiesDataPtr;

result_t setSignalType(..);
result_ getSignalType(..);
result_t setSignalData(..);
result_t getSignalData(..);
result_t setSignalDataLen(..);
result_t getSignalDataLen(..);

#endif

signal_properties_data.c:

#include "signal_properties_data.h"

typdef struct {
  SignalDataValueType signalPropertiesDataType;
  void* signalPropertiesDataValue;
} SignalPropertiesData;

signal_properties_data_mgr.h:

#ifdef _SIGNAL_PROPERTIES_DATA_MGR_H
#define _SIGNAL_PROPERTIES_DATA_MGR_H

#include "signal_properties_data.h"
#include "signal_scenario.h"

typedef SignalScenarioDesc* SignalScenarioDescPtr;

result_t createSignalPropertiesData(SignalPropertiesDataPtr *signalPropDataPtr, eSignalType desiredSignalType);

result_t freeSignalPropertiesData(..);

result_t associateSignalToggleScenario(SignalPropertiesDataPtr *signalPropDataPtr, SignalScenPtr signalScenPtr);

result_t disassociateSignalToggleScenario(SignalPropertiesDataPtr *signalPropDataPtr, SignalScenarioDescPtr signalScenPtr);

#endif 

signal_properties_data_mgr.c:

#include "signal_properties_data_mgr.h"

typedef struct {
  toggleFuncPtr fptr;
} SignalScenarioDesc;

Answer 1

Avoid going for void *. It loses the benefits of prototypes and is not necessary,

Since this is C, you should write in signalmanager.h

#ifndef SIGNAL_MANAGER_H_INCLUDED
#define SIGNAL_MANAGER_H_INCLUDED

typedef struct SignalDesc* SignalDescPtr;

int createSignal(SignalDescPtr signalDescPtr);

int destroySignal(void);

#endif

Changes:

1. Critical: the idiom is #ifndef MACRO / #define MACRO / #endif. You used #ifdef which won't work.
2. Place typedef before it is used.
3. Add explicit (void) to make destroySignal(void) into a prototype. Your version simply says 'there is a function destroySignal() that returns an int but it takes an unspecified (but not variadic) argument list'.
4. Do not use reserved name space (leading underscore, capital letter) for the header protection guard.

I prefer not to hide pointers in data type typedefs, so I'd probably write:

#ifndef SIGNAL_MANAGER_H_INCLUDED
#define SIGNAL_MANAGER_H_INCLUDED

typedef struct SignalDesc SignalDesc;

extern int createSignal(SignalDesc *sigdesc);

extern int destroySignal(void);

#endif /* SIGNAL_MANAGER_H_INCLUDED */

I'm not sure that the interfaces to the create and destroy are correct, but that's another subject for discussion. I'd normally expect to find that the interfaces are more like:

extern SignalDesc *createSignal(const char *name, int signum);
extern void destroySignal(SignalDesc *sigdesc);

The implementation file signal_manager.c would then define the structure type and use it; the external interface is through functions that work with pointers.

#include "signal_manager.h"
#include "signal_properties_data.h"

struct SignalDesc
{
    char                 *signalName;
    unsigned int          signalId;
    SignalPropertiesData *signalProperties;
};

The signal_properties_data.h needs similar cleaning up:

#ifndef SIGNAL_PROPERTIES_DATA_H_INCLUDED
#define SIGNAL_PROPERTIES_DATA_H_INCLUDED

typedef enum {
  SIGNAL_DATA_INT_TYPE,
  SIGNAL_DATA_UNSIGNED_INT_TYPE,
  SIGNAL_DATA_FLOAT_TYPE,
     :
  SIGNAL_DATA_UNSPECIFIED_BASIC_TYPE
} eSignalBasicType;

typedef enum {
  SIGNAL_DATA_LIST_ARRAY_TYPE,
  SIGNAL_DATA_LIST_ADT_TYPE,
   :
   :
  SIGNAL_DATA_LIST_UNSPECIFIED_TYPE
} eSignalComplexType

typdef  union {
  eSignalBasicType signalBasicType;
  eSignalComplexType signalComplexType;
} eSignalType;

typedef struct {
  eSignalType signalType;
  unsigned int signalDataLen;
} SignalDataValueType;

/* Huge hole in types here - or is SignalValueDataType what you're after? */
typedef struct SignalPropertiesData SignalPropertiesData;

result_t setSignalType(..);
result_t getSignalType(..);
result_t setSignalData(..);
result_t getSignalData(..);
result_t setSignalDataLen(..);
result_t getSignalDataLen(..);

#endif  /* SIGNAL_PROPERTIES_DATA_H_INCLUDED */

This revised header is not self-contained yet. It does not define result_t, so it should include the header that does. I assume the ... notation in the function calls is "do not want to specify in this question" because it isn't valid in C; you must have one argument of known type before you specify the ellipsis.

It is not clear from the functions in the header why the user of the header needs to know about the types that are defined in it. Think of a header as a resource that will be shared. It 'belongs to' or describes the external interface to a file (or a small set of files). It gives the users the minimum data that they need to use the facilities provided by the code, but no more than the minimum. You sometimes find that a set of files implementing a facility will need a private header to share between themselves as well as the public header that other code ('customer' code or 'consumer' code) uses.

The key to opaque types is that the consumer doesn't need to know the internal details of a structure to be able to use pointers to the structure type (see Which part of the C Standard allows this code to compile?, Does the C standard consider that there are one or two struct uperms_entry types in this header? and How to structure header files in C for some more insight).

Answer 2

I am not sure that I fully understand what your needs are, but I think that you could look at WIN32 handles for a reference implementation.

A short example would be to define a macro that lets you define custom handles like this:

/* example.h */

#ifndef _EXAMPLE_H
#define _EXAMPLE_H

/* Define macro */
#define DECLARE_HANDLE(HandleName) typedef struct HandleName##Tag * HandleName

/* Declare some handles */
DECLARE_HANDLE(SomeHandle);
DECLARE_HANDLE(SomeOtherHandle);

#endif /* _EXAMPLE_H */

/* example.c */

#include "example.h"

struct SomeHandleTag {
    int foo;
};

struct SomeOtherHandleTag {
    int foo;
};