C++ (Cpp) core_command_get_argument_value_intの例

コード例 #1

ファイル: process.c プロジェクト: huyba/biosal

void process_init(struct thorium_actor *self)
{
    struct process *concrete_self;
    int argc;
    char **argv;

    argc = thorium_actor_argc(self);
    argv = thorium_actor_argv(self);

    concrete_self = thorium_actor_concrete_actor(self);
    core_vector_init(&concrete_self->actors, sizeof(int));

    thorium_actor_add_action(self, ACTION_START, process_start);
    thorium_actor_add_action(self, ACTION_ASK_TO_STOP, process_stop);
    thorium_actor_add_action(self, ACTION_PING, process_ping);
    thorium_actor_add_action(self, ACTION_PING_REPLY, process_ping_reply);
    thorium_actor_add_action(self, ACTION_NOTIFY, process_notify);

    concrete_self->passed = 0;
    concrete_self->failed = 0;
    concrete_self->events = 0;

    concrete_self->minimum_buffer_size = 16;
    concrete_self->maximum_buffer_size = 512*1024;

    if (core_command_has_argument(argc, argv, MIN_BUFFER_SIZE_OPTION)) {
        concrete_self->maximum_buffer_size = core_command_get_argument_value_int(argc, argv, MIN_BUFFER_SIZE_OPTION);
    }

    if (core_command_has_argument(argc, argv, MAX_BUFFER_SIZE_OPTION)) {
        concrete_self->maximum_buffer_size = core_command_get_argument_value_int(argc, argv, MAX_BUFFER_SIZE_OPTION);
    }

    concrete_self->event_count = 100000;

    if (core_command_has_argument(argc, argv, EVENT_COUNT_OPTION)) {
        concrete_self->event_count = core_command_get_argument_value_int(argc, argv, EVENT_COUNT_OPTION);
    }

    concrete_self->concurrent_event_count = 8;

    if (core_command_has_argument(argc, argv, CONCURRENT_EVENT_COUNT_OPTION)) {
        concrete_self->concurrent_event_count = core_command_get_argument_value_int(argc, argv, CONCURRENT_EVENT_COUNT_OPTION);
    }

    concrete_self->active_messages = 0;

    printf("%s/%d using %s %d %s %d %s %d %s %d\n",
                    thorium_actor_script_name(self),
                    thorium_actor_name(self),
                    MIN_BUFFER_SIZE_OPTION,
                    concrete_self->minimum_buffer_size,
                    MAX_BUFFER_SIZE_OPTION,
                    concrete_self->maximum_buffer_size,
                    EVENT_COUNT_OPTION,
                    concrete_self->event_count,
                    CONCURRENT_EVENT_COUNT_OPTION,
                    concrete_self->concurrent_event_count);
}

コード例 #2

ファイル: command.c プロジェクト: bioparr/biosal

int biosal_command_get_kmer_length(int argc, char **argv)
{
    int kmer_length;
    int provided_value;

    kmer_length = BIOSAL_DEFAULT_KMER_LENGTH;

    if (core_command_has_argument(argc, argv, "-k")) {
        provided_value = core_command_get_argument_value_int(argc, argv, "-k");

        /*
         * Use a odd kmer length
         */
        if (provided_value % 2 == 0) {
            ++provided_value;
        }

        kmer_length = provided_value;
    }

    /*
    printf("DEBUG kmer_length %d\n", kmer_length);
    */

    return kmer_length;
}

コード例 #3

ファイル: source.c プロジェクト: bioparr/biosal

static void source_init(struct thorium_actor *self)
{
    struct source *concrete_self;
    int argc;
    char **argv;

    concrete_self = thorium_actor_concrete_actor(self);

    concrete_self->message_count = 0;

    argc = thorium_actor_argc(self);
    argv = thorium_actor_argv(self);

    concrete_self->event_count = DEFAULT_EVENT_COUNT;

    if (core_command_has_argument(argc, argv, OPTION_EVENT_COUNT)) {
        concrete_self->event_count = core_command_get_argument_value_int(argc, argv, OPTION_EVENT_COUNT);
    }

    core_vector_init(&concrete_self->targets, sizeof(int));
    core_vector_set_memory_pool(&concrete_self->targets,
                    thorium_actor_get_persistent_memory_pool(self));

    concrete_self->target = -1;
}

コード例 #4

ファイル: command.c プロジェクト: bioparr/biosal

int biosal_command_get_minimum_coverage(int argc, char **argv)
{
    int value;

    value = BIOSAL_DEFAULT_MINIMUM_COVERAGE;

    if (core_command_has_argument(argc, argv, "-minimum-coverage")) {
        value = core_command_get_argument_value_int(argc, argv, "-minimum-coverage");
    }

    return value;
}