/* 객체 체계를 돕는 매크로와, 해치는 매크로 하나.
   (1) 타입이 틀린 포인터를 거절하는 container_of
   (2) GObject 의 GTK_WIDGET(x) 같은 결의 검사하는 하향 캐스트
   (3) 인자를 두 번 평가하는 「표를 거쳐 부르기」 매크로 --- 그리고 그 고침 */
#include <stddef.h>
#include <stdio.h>

/* (1) sizeof 안의 비교는 평가되지 않지만 타입 검사는 받는다:
   다른 타입의 포인터를 비교하는 것은 제약 위반이라 컴파일러가 진단해야 하고,
   -Werror 를 켜면 틀린 `ptr` 이 빌드를 멈춘다. */
#define container_of(ptr, type, member)                                   \
    ((void)sizeof((ptr) == &((type *)nullptr)->member),                   \
     (type *)((char *)(ptr) - offsetof(type, member)))

enum kind { KIND_CIRCLE = 0xC1, KIND_RECT = 0x4E };
struct shape;
struct shape_ops { enum kind kind; double (*area)(const struct shape *); };
struct shape  { const struct shape_ops *ops; };
/* base 가 첫 멤버가 아니어도 container_of 는 된다 */
struct circle { double r; struct shape base; };

static double circle_area(const struct shape *s)
{
    const struct circle *c = container_of(s, const struct circle, base);
    return 3.0 * c->r * c->r;
}
static const struct shape_ops circle_ops = { KIND_CIRCLE, circle_area };
static const struct shape_ops rect_ops   = { KIND_RECT, nullptr };

/* (2) 캐스트를 믿기 전에 종류를 본다. 틀린 캐스트는 쓰레기가 아니라 nullptr 가 된다.
   (`s` 를 세 번 적으므로 이것에도 평범한 변수만 넘긴다 --- s++ 는 안 된다.) */
#define AS_CIRCLE(s) ((s) && (s)->ops->kind == KIND_CIRCLE                  \
                      ? container_of((s), struct circle, base) : (struct circle *)nullptr)

/* (3) 무해해 보이지만… */
#define SHAPE_AREA(s) ((s)->ops->area(s))
/* …함수로 쓰는 편이 안전하다: 인자를 정확히 한 번 평가하고, 타입도 검사한다 */
static inline double shape_area(const struct shape *s) { return s->ops->area(s); }

static int evaluations;
static struct shape *next_shape(struct shape *s) { evaluations++; return s; }

int main(void)
{
    struct circle c = { .r = 2.0, .base.ops = &circle_ops };
    struct shape *s = &c.base;
    struct shape rect = { &rect_ops }, *other = &rect;

    printf("container_of: back to the circle, r = %g\n",
           container_of(s, struct circle, base)->r);
    /* container_of(&c.r, struct circle, base) 는 안 된다: &c.r 은 double * 다. */

    struct circle *ok = AS_CIRCLE(s), *no = AS_CIRCLE(other);
    printf("AS_CIRCLE(circle)    : %s\n", ok ? "a circle" : "nullptr");
    printf("AS_CIRCLE(rectangle) : %s\n", no ? "a circle" : "nullptr");

    evaluations = 0;
    double a = SHAPE_AREA(next_shape(s));
    printf("SHAPE_AREA(next_shape(s)) = %g, next_shape ran %d times\n", a, evaluations);
    evaluations = 0;
    a = shape_area(next_shape(s));
    printf("shape_area(next_shape(s)) = %g, next_shape ran %d time\n", a, evaluations);
    return 0;
}

/* 도형 백만 개의 넓이 합을 세 가지로 구한다.
   (1) 객체: 도형마다 따로 할당하고, 메서드 표를 거쳐 부른다
   (2) 태그 달린 구조체를 한 배열에, 태그로 switch
   (3) 도형의 종류마다 배열 하나, 배열마다 평범한 반복문
   ★ 이 예제는 시간을 잰다. 배수만 인쇄한다. */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N      (1u << 20)
#define ROUNDS 5

/* (1) 객체의 길 */
struct shape;
struct shape_ops { double (*area)(const struct shape *); };
struct shape { const struct shape_ops *ops; };
struct circle { struct shape base; double r; };
struct rect   { struct shape base; double w, h; };
static double circle_area(const struct shape *s)
{ const struct circle *c = (const struct circle *)s; return 3.14159 * c->r * c->r; }
static double rect_area(const struct shape *s)
{ const struct rect *r = (const struct rect *)s; return r->w * r->h; }
static const struct shape_ops circle_ops = { circle_area }, rect_ops = { rect_area };

/* (2) 태그의 길 */
enum kind { CIRCLE, RECT };
struct tagged { enum kind kind; double a, b; };

/* (3) 종류별 배열의 길 */
static double *radius, *width, *height;
static uint32_t n_circles, n_rects;

static struct shape **objs;
static struct tagged *tags;
static volatile double sink;

static double now(void) { return (double)clock() / CLOCKS_PER_SEC; }
static double by_table(void)
{
    double t = now(), s = 0;
    for (uint32_t i = 0; i < N; i++) s += objs[i]->ops->area(objs[i]);
    sink = s; return now() - t;
}
static double by_switch(void)
{
    double t = now(), s = 0;
    for (uint32_t i = 0; i < N; i++)
        switch (tags[i].kind) {
        case CIRCLE: s += 3.14159 * tags[i].a * tags[i].a; break;
        case RECT:   s += tags[i].a * tags[i].b; break;
        }
    sink = s; return now() - t;
}
static double by_kind(void)
{
    double t = now(), s = 0;
    for (uint32_t i = 0; i < n_circles; i++) s += 3.14159 * radius[i] * radius[i];
    for (uint32_t i = 0; i < n_rects; i++)   s += width[i] * height[i];
    sink = s; return now() - t;
}

static int cmp(const void *a, const void *b)
{ double x = *(const double *)a, y = *(const double *)b; return (x > y) - (x < y); }
static double median(double (*job)(void))
{
    double r[ROUNDS];
    job();
    for (int i = 0; i < ROUNDS; i++) r[i] = job();
    qsort(r, ROUNDS, sizeof *r, cmp);
    return r[ROUNDS / 2];
}

int main(void)
{
    objs = malloc(N * sizeof *objs); tags = malloc(N * sizeof *tags);
    radius = malloc(N * sizeof *radius);
    width = malloc(N * sizeof *width);
    height = malloc(N * sizeof *height);
    if (!objs || !tags || !radius || !width || !height)
        { puts("out of memory"); return 1; }

    uint64_t rng = 0x9E3779B97F4A7C15u;
    for (uint32_t i = 0; i < N; i++) {
        rng ^= rng << 13; rng ^= rng >> 7; rng ^= rng << 17;
        double x = (double)(i % 100) / 10.0;
        if (rng >> 63) {                     /* 종류가 무작위 순서로 온다 */
            struct circle *c = malloc(sizeof *c);
            if (!c) { puts("out of memory"); return 1; }
            *c = (struct circle){ { &circle_ops }, x };
            objs[i] = &c->base;
            tags[i] = (struct tagged){ CIRCLE, x, 0 };
            radius[n_circles++] = x;
        } else {
            struct rect *r = malloc(sizeof *r);
            if (!r) { puts("out of memory"); return 1; }
            *r = (struct rect){ { &rect_ops }, x, 2 };
            objs[i] = &r->base;
            tags[i] = (struct tagged){ RECT, x, 2 };
            width[n_rects] = x; height[n_rects++] = 2;
        }
    }

    double t = median(by_table), s = median(by_switch), k = median(by_kind);
    printf("%u shapes, circles and rectangles in random order\n", N);
    if (k > 0) {
        printf("  method table : %5.1f times as long as per-kind arrays\n", t / k);
        printf("  tag + switch : %5.1f times as long as per-kind arrays\n", s / k);
    } else puts("  the clock is too coarse on this machine to tell them apart");

    for (uint32_t i = 0; i < N; i++) free(objs[i]);
    free(objs); free(tags); free(radius); free(width); free(height);
    return 0;
}

/* 종류가 닫혀 있을 때 메서드 표 대신 쓰는 길: 태그, 공용체, 그리고 switch.
   default 를 일부러 두지 않았다 --- 그래야 새 종류의 도형이 더해졌는데 이 함수가
   그것을 모를 때 컴파일러가 알려 준다. */
#include <stdio.h>

enum shape_kind {
    SHAPE_CIRCLE,
    SHAPE_RECT,
#ifdef ADD_TRIANGLE
    SHAPE_TRIANGLE,              /* 나중에 더한 새 종류 */
#endif
};

struct shape {
    enum shape_kind kind;
    union {
        struct { double r; } circle;
        struct { double w, h; } rect;
#ifdef ADD_TRIANGLE
        struct { double base, height; } triangle;
#endif
    };
};

static double area(const struct shape *s)
{
    switch (s->kind) {
    case SHAPE_CIRCLE: return 3.0 * s->circle.r * s->circle.r;
    case SHAPE_RECT:   return s->rect.w * s->rect.h;
    }
    return 0.0;                  /* 올바른 종류라면 닿지 않는다 */
}

int main(void)
{
    struct shape a[] = {
        { .kind = SHAPE_CIRCLE, .circle = { 1.0 } },
        { .kind = SHAPE_RECT,   .rect = { 2.0, 3.0 } },
    };
    double total = 0;
    for (size_t i = 0; i < sizeof a / sizeof a[0]; i++) total += area(&a[i]);
    printf("total area %g\n", total);
    return 0;
}