自学教程：C++ ASSERTN函数代码示例

int bus_write(struct bus_t *self_p,              int id,              const void *buf_p,              size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(buf_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    int number_of_receivers;    struct bus_listener_t *curr_p;    rwlock_reader_take(&self_p->rwlock);    curr_p = (struct bus_listener_t *)binary_tree_search(        &self_p->listeners, id);    number_of_receivers = 0;    while (curr_p != NULL) {        ((struct chan_t *)curr_p->chan_p)->write(curr_p->chan_p,                                                 buf_p,                                                 size);        number_of_receivers++;        curr_p = curr_p->next_p;    }    rwlock_reader_give(&self_p->rwlock);    return (number_of_receivers);}

ssize_t settings_write_by_name(const char *name_p,                               const void *src_p,                               size_t size){    ASSERTN(name_p != NULL, EINVAL);    ASSERTN(src_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    const FAR struct setting_t *setting_p;    /* Find the setting in the settings array. */    setting_p = &settings[0];    while (setting_p->name_p != NULL) {        if (std_strcmp(name_p, setting_p->name_p) == 0) {            if (size > setting_p->size) {                return (-1);            }            return (settings_write(setting_p->address, src_p, size));        }        setting_p++;    }    return (-1);}

int spi_init(struct spi_driver_t *self_p,             struct spi_device_t *dev_p,             struct pin_device_t *ss_pin_p,             int mode,             int speed,             int polarity,             int phase){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(dev_p != NULL, EINVAL);    ASSERTN(ss_pin_p != NULL, EINVAL);    self_p->dev_p = dev_p;    self_p->mode = mode;    self_p->speed = speed;    self_p->polarity = polarity;    self_p->phase = phase;    return (spi_port_init(self_p,                          dev_p,                          ss_pin_p,                          mode,                          speed,                          polarity,                          phase));}

int queue_init(struct queue_t *self_p,               void *buf_p,               size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN((buf_p == NULL)            || ((buf_p != NULL) && (size > 0)), EINVAL);    chan_init(&self_p->base,              (chan_read_fn_t)queue_read,              (chan_write_fn_t)queue_write,              (chan_size_fn_t)queue_size);    chan_set_write_isr_cb(&self_p->base, (chan_write_fn_t)queue_write_isr);    self_p->buffer.begin_p = buf_p;    self_p->buffer.read_p = buf_p;    self_p->buffer.write_p = buf_p;    self_p->buffer.end_p = &((char*)buf_p)[size];    self_p->buffer.size = size;    self_p->state = QUEUE_STATE_INITIALIZED;    self_p->buf_p = NULL;    self_p->size = 0;    self_p->left = 0;    return (0);}

int heap_free(struct heap_t *self_p,              void *buf_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(buf_p != NULL, EINVAL);    int count;    struct heap_buffer_header_t *header_p;    header_p = &((struct heap_buffer_header_t *)buf_p)[-1];    sys_lock();    if (header_p->count > 0) {        header_p->count--;        count = header_p->count;                /* Free when count is zero. */        if (count == 0) {            if (header_p->u.fixed_p != NULL) {                count = free_fixed_size(self_p, header_p);            } else {                count = free_dynamic_buffer(self_p, header_p);            }        }    } else {        count = -1;    }    sys_unlock();    return (count);}

int http_server_init(struct http_server_t *self_p,                     struct http_server_listener_t *listener_p,                     struct http_server_connection_t *connections_p,                     const char *root_path_p,                     const struct http_server_route_t *routes_p,                     http_server_route_callback_t on_no_route){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(listener_p != NULL, EINVAL)    ASSERTN(connections_p != NULL, EINVAL);    ASSERTN(routes_p != NULL, EINVAL);    ASSERTN(on_no_route != NULL, EINVAL);    struct http_server_connection_t *connection_p;    self_p->listener_p = listener_p;    self_p->connections_p = connections_p;    self_p->root_path_p = root_path_p;    self_p->routes_p = routes_p;    self_p->on_no_route = on_no_route;    connection_p = self_p->connections_p;    while (connection_p->thrd.name_p != NULL) {        connection_p->state = http_server_connection_state_free_t;        connection_p->self_p = self_p;        event_init(&connection_p->events);        connection_p++;    }    event_init(&self_p->events);    return (0);}

ssize_t event_read(struct event_t *self_p,                   void *buf_p,                   size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(buf_p != NULL, EINVAL);    ASSERTN(size == sizeof(uint32_t), EINVAL);    uint32_t *mask_p, mask;    mask_p = (uint32_t *)buf_p;    sys_lock();    mask = (self_p->mask & *mask_p);    /* Event already set? Otherwise wait for it. */    if (mask != 0) {        *mask_p = mask;    } else {        self_p->base.reader_p = thrd_self();        thrd_suspend_isr(NULL);        *mask_p = (self_p->mask & *mask_p);    }    /* Remove read events from the event channel. */    self_p->mask &= (~(*mask_p));    sys_unlock();    return (size);}

int pin_write(struct pin_driver_t *self_p, int value){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN((value == 0) || (value == 1), EINVAL);    return (pin_port_write(self_p, value));}

int network_interface_wifi_init(struct network_interface_wifi_t *self_p,                                const char *name_p,                                struct network_interface_wifi_driver_t *driver_p,                                void *arg_p,                                const char *ssid_p,                                const char *password_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(name_p != NULL, EINVAL);    ASSERTN(driver_p != NULL, EINVAL);    ASSERTN(ssid_p != NULL, EINVAL);    self_p->network_interface.name_p = name_p;    self_p->network_interface.start =        (network_interface_start_t)network_interface_wifi_start;    self_p->network_interface.stop =        (network_interface_stop_t)network_interface_wifi_stop;    self_p->network_interface.is_up =        (network_interface_is_up_t)network_interface_wifi_is_up;    self_p->network_interface.set_ip_info =        (network_interface_set_ip_info_t)network_interface_wifi_set_ip_info;    self_p->network_interface.get_ip_info =        (network_interface_get_ip_info_t)network_interface_wifi_get_ip_info;    self_p->driver_p = driver_p;    self_p->arg_p = arg_p;    self_p->ssid_p = ssid_p;    self_p->password_p = password_p;    self_p->info_p = NULL;    /* Initialize the driver. */    driver_p->init(arg_p);        return (0);}

ssize_t settings_read(void *dst_p, size_t src, size_t size){    ASSERTN(dst_p != NULL, EINVAL);    ASSERTN(src >= 0, EINVAL);    ASSERTN(size > 0, EINVAL);    return (settings_port_read(dst_p, src, size));}

ssize_t settings_write(size_t dst, const void *src_p, size_t size){    ASSERTN(dst >= 0, EINVAL);    ASSERTN(src_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    return (settings_port_write(dst, src_p, size));}

int network_interface_wifi_get_ip_info(struct network_interface_wifi_t *self_p,                                       struct inet_if_ip_info_t *info_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(info_p != NULL, EINVAL);    return (self_p->driver_p->get_ip_info(self_p->arg_p, info_p));}

ssize_t spi_get(struct spi_driver_t *self_p,                uint8_t *data_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(data_p != NULL, EINVAL);    return (spi_read(self_p, data_p, 1));}

ssize_t spi_read(struct spi_driver_t *self_p,                 void *rxbuf_p,                 size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(rxbuf_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    return (spi_transfer(self_p, rxbuf_p, NULL, size));}

ssize_t can_read(struct can_driver_t *self_p,                 struct can_frame_t *frame_p,                 size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(frame_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    return (queue_read(&self_p->chin, frame_p, size));}

ssize_t spi_write(struct spi_driver_t *self_p,                  const void *txbuf_p,                  size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(txbuf_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    return (spi_transfer(self_p, NULL, txbuf_p, size));}

int dac_convert(struct dac_driver_t *self_p,                uint32_t *samples_p,                size_t length){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(samples_p != NULL, EINVAL);    ASSERTN(length > 0, EINVAL);    return (dac_port_convert(self_p, samples_p, length));}

ssize_t can_write(struct can_driver_t *self_p,                  const struct can_frame_t *frame_p,                  size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(frame_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    return (chan_write(&self_p->base, frame_p, size));}

ssize_t spi_transfer(struct spi_driver_t *self_p,                     void *rxbuf_p,                     const void *txbuf_p,                     size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN((rxbuf_p != NULL) || (txbuf_p != NULL), EINVAL);    ASSERTN(size > 0, EINVAL);    return(spi_port_transfer(self_p, rxbuf_p, txbuf_p, size));}

int pin_init(struct pin_driver_t *self_p,             struct pin_device_t *dev_p,             int mode){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(dev_p != NULL, EINVAL);    self_p->dev_p = dev_p;    return (pin_port_init(self_p, dev_p, mode));}

ssize_t usb_device_write_isr(struct usb_device_driver_t *self_p,                             int endpoint,                             const void *buf_p,                             size_t size){    ASSERTN(self_p != NULL, INVAL);    ASSERTN(endpoint > 0, INVAL);    ASSERTN(buf_p != NULL, INVAL);    ASSERTN(size > 0, INVAL);    return (usb_device_port_write_isr(self_p, endpoint, buf_p, size));}

int configfile_init(struct configfile_t *self_p,                    char *buf_p,                    size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(buf_p != NULL, EINVAL);    ASSERTN(size > 0, EINVAL);    self_p->buf_p = buf_p;    self_p->size = size;    return (0);}

int bus_listener_init(struct bus_listener_t *self_p,                      int id,                      void *chan_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(chan_p != NULL, EINVAL);    self_p->base.key = id;    self_p->id = id;    self_p->chan_p = chan_p;    self_p->next_p = NULL;    return (0);}

ssize_t event_write(struct event_t *self_p,                    const void *buf_p,                    size_t size){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(buf_p != NULL, EINVAL);    ASSERTN(size == sizeof(uint32_t), EINVAL);    sys_lock();    size = event_write_isr(self_p, buf_p, size);    sys_unlock();    return (size);}

int dac_init(struct dac_driver_t *self_p,             struct dac_device_t *dev_p,             struct pin_device_t *pin0_dev_p,             struct pin_device_t *pin1_dev_p,             int sampling_rate){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(sampling_rate > 0, EINVAL);    return (dac_port_init(self_p,                          dev_p,                          pin0_dev_p,                          pin1_dev_p,                          sampling_rate));}

int hash_map_add(struct hash_map_t *self_p,                 long key,                 void *value_p){    ASSERTN(self_p != NULL, EINVAL);    ASSERTN(value_p != NULL, EINVAL);    int hash;    struct hash_map_bucket_t *bucket_p;    struct hash_map_entry_t *entry_p;    /* Hash key. */    hash = self_p->hash(key);    hash %= self_p->buckets_max;    bucket_p = &self_p->buckets_p[hash];    /* Is the key already in map? */    if (bucket_p->list_p != NULL) {        entry_p = bucket_p->list_p;        while (entry_p != NULL) {            if (entry_p->key == key) {                entry_p->value_p = value_p;                return (0);            }            entry_p = entry_p->next_p;        }    }    /* Allocate new entry. */    entry_p = entry_alloc(self_p);    if (entry_p == NULL) {        return (-ENOMEM);    }    /* Initiate entry.*/    entry_p->key = key;    entry_p->value_p = value_p;    /* Insert in list. */    entry_p->next_p = bucket_p->list_p;    bucket_p->list_p = entry_p;    return (0);}

void *hash_map_get(struct hash_map_t *self_p,                   long key){    ASSERTN(self_p != NULL, EINVAL);    int hash;    struct hash_map_bucket_t *bucket_p;    struct hash_map_entry_t *entry_p;    /* Hash key. */    hash = self_p->hash(key);    hash %= self_p->buckets_max;    bucket_p = &self_p->buckets_p[hash];    /* Search for key. */    if (bucket_p->list_p != NULL) {        entry_p = bucket_p->list_p;                while (entry_p != NULL) {            if (entry_p->key == key) {                return (entry_p->value_p);            }                        entry_p = entry_p->next_p;        }            }    return (NULL);}

int http_server_start(struct http_server_t *self_p){    ASSERTN(self_p != NULL, EINVAL);    struct http_server_connection_t *connection_p;    /* Spawn the listener thread. */    self_p->listener_p->thrd.id_p =        thrd_spawn(listener_main,                   self_p,                   0,                   self_p->listener_p->thrd.stack.buf_p,                   self_p->listener_p->thrd.stack.size);    connection_p = self_p->connections_p;    /* Spawn the connection threads. */    while (connection_p->thrd.stack.buf_p != NULL) {        connection_p->thrd.id_p =            thrd_spawn(connection_main,                       connection_p,                       0,                       connection_p->thrd.stack.buf_p,                       connection_p->thrd.stack.size);        connection_p++;    }    return (0);}

ssize_t spi_put(struct spi_driver_t *self_p,                uint8_t data){    ASSERTN(self_p != NULL, EINVAL);    return (spi_write(self_p, &data, 1));}

int usb_device_start(struct usb_device_driver_t *self_p){    ASSERTN(self_p != NULL, INVAL);    module.driver_p = self_p;    return (usb_device_port_start(self_p));}