#include "gtest/gtest.h"
#include <iostream>

struct Node{
    int value;
    Node *next;
};
typedef struct Node * NodePtr;

bool isSorted(NodePtr head);
void swap(NodePtr *prev, NodePtr p);

NodePtr sort_1(NodePtr head) {
    if (head == NULL) {
        return head;
    }
    
    while (!isSorted(head)) {
        NodePtr ptr = head;
        NodePtr *prev = &head;
        while (ptr->next != NULL) {
            if (ptr->value > ptr->next->value) {
                swap(prev, ptr);
            }
            ptr = (*prev)->next;
            prev = &((**prev).next); // hate this...
        }
    }
    return head;
}

bool isSorted(NodePtr head) {
    if (head == NULL) {
        return true;
    }
    
    NodePtr ptr = head;
    while (ptr->next != NULL) {
        if (ptr->value > ptr->next->value) {
            return false;
        }
        ptr = ptr->next;
    }
    return true;
}

/*
 *      -> [ ] -> []
 *    /     |
 * prev     p
 */
void swap(NodePtr *prev, NodePtr p) {
    *prev = p->next;
    NodePtr tmp = p->next->next;
    p->next->next = p;
    p->next = tmp;
}

NodePtr insert(NodePtr list, NodePtr node);

NodePtr sort_2(NodePtr node) {
    NodePtr sub = NULL;
    if (node->next != NULL) {
        sub = sort_2(node->next);
    }
    
    return insert(sub, node);
}

NodePtr insert(NodePtr list, NodePtr node) {
    if (list == NULL) {
        return node;
    }
    
    // find the position to insert
    NodePtr ptr = list;
    NodePtr prev = NULL;
    while (ptr != NULL && ptr->value < node->value) {
        prev = ptr;
        ptr = ptr->next;
    }
    
    NodePtr newHead = list;
    if (prev == NULL) {
        node->next = ptr;
        newHead = node;
    } else {
        prev->next = node;
        node->next = ptr;
    }

    return newHead;
}

<project xmlns="http://maven.apache.org/POM/4.0.0" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hong</groupId>
  <artifactId>plain-jpa-app</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <dependencies>
    <!-- use hibernate-entitymanager, if you are using hibernate simply as jpa provider -->
    <!--  <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.3.10.Final</version>
    </dependency> -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.3.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.persistence</groupId>
      <artifactId>javax.persistence</artifactId>
      <version>2.1.0</version>
    </dependency>
    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
      <version>2.8.1</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.36</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.1.3</version>
    </dependency>
  </dependencies>
</project>

package hello;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.*;

import org.joda.time.DateTime;

@Entity
// @Table can be omitted, if defaults are ok. however, specify 'name' of @Table
// is better, so that the mapping between entity and table wouldn't break 
// if we refactor Order class name later on
@Table(name = "SALES_ORDER")
public class Order {
    @Id
    @SequenceGenerator(name = "ORDER_SEQ", sequenceName = "ORDER_SEQ", allocationSize = 1)
    @GeneratedValue(generator = "ORDER_SEQ", strategy = GenerationType.AUTO)
    private Long id;
    
    // do 'optional = false' in @ManyToOne and 'nullable = false' in @JoinColumn
    // have the same effect?
    @ManyToOne(optional = false)
    @JoinColumn(name = "CUSTOMER_ID", nullable = false)
    private Customer customer;
    
    @Column(name = "AMOUNT")
    private BigDecimal amount;
    
    /*
     * https://docs.oracle.com/javaee/6/tutorial/doc/bnbqa.html
     * for 'date', jpa supports java.util.Date, java.util.Calendar, java.sql.Date, 
     * java.sql.Time, java.sql.TimeStamp. 
     * 
     * http://www.joda.org/joda-time/
     * it's said joda time the best choice before java 1.8.
     * 
     * since the app uses java 1.7, and also it needs time for jpa to support java
     * 1.8's 'date class', so we use joda time (via a converter) in this app.
     */
    @Column(name = "CREATED_TIME")
    @Convert(converter = JodaTimeConverter.class)
    private DateTime createdTime;
    
    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
    private final List<OrderLine> lines = new ArrayList<OrderLine>();
    
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public Customer getCustomer() {
        return customer;
    }
    
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    
    public BigDecimal getAmount() {
        return amount;
    }
    
    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }
    
    public DateTime getCreatedTime() {
        return createdTime;
    }
    
    public void setCreatedTime(DateTime createdTime) {
        this.createdTime = createdTime;
    }
    
    public List<OrderLine> getLines() {
        return lines;
    }
}

package hello;

import java.math.BigDecimal;

import javax.persistence.*;

@Entity
@Table(name = "ORDER_LINE")
public class OrderLine {
    @Id
    @SequenceGenerator(name = "ORDER_LINE_SEQ", sequenceName = "ORDER_LINE_SEQ", allocationSize = 1)
    @GeneratedValue(generator = "ORDER_LINE_SEQ", strategy = GenerationType.AUTO)
    private Long id;
    
    @ManyToOne(optional = false)
    @JoinColumn(name = "ORDER_ID", nullable = false, updatable = false)
    private Order parent;
    
    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID", nullable = false)
    private Product product;
    
    @Column(name = "QUANTITY")
    private BigDecimal quantity;
    
    @Column(name = "PRICE")
    private BigDecimal price;
    
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public Order getParent() {
        return parent;
    }
    
    public void setParent(Order order) {
        parent = order;
    }
    
    public Product getProduct() {
        return product;
    }
    
    public void setProduct(Product product) {
        this.product = product;
    }
    
    public BigDecimal getQuantity() {
        return quantity;
    }
    
    public void setQuantity(BigDecimal quantity) {
        this.quantity = quantity;
    }
    
    public BigDecimal getPrice() {
        return price;
    }
    
    public void setPrice(BigDecimal price) {
        this.price = price;
    }
}

#include <stdarg.h> 
#include <stdio.h>
    
void printNDoubles(int n, ... ) {        /* 函数声明中的"..."表示可变长度参数 */
    va_list args;                        /* 对应的类型 */
    va_start(args, n);                   /* 找到可变长度参数列表的起始处 */

    int i = 0;
    for (; i < n; ++i) {
        double d = va_arg(args, double); /* 取可变长度参数列表中的下一个参数 */
        printf("%dth double is:%f\n", i, d);
    }
    va_end( args );                      /* 做一下清理工作 */
}

int main(int argc, char **argv) {
    printNDoubles(3, 1.1, 2.2, 3.3);

    return 0;
}

typedef unsigned char *va_list;
#define va_start(list, param) (list = (((va_list)&param) + sizeof(param)))
#define va_arg(list, type)    (*(type *)((list += sizeof(type)) - sizeof(type)))

int main(int argc, char **argv) {
    int s1 = 42;
    int s2 = 8;
    char s3[] = "hello";
    /* ... */
}

int main(int argc, char **argv) {
	/* ... */
	printf("%s",argv[1]);
	/* ... */
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv) {
   	int magic = 0xbad15bad;
   	char *str = (char *)malloc(20);
   	memset(str, 0, 20);

   	printf(argv[1]); /* 允许用户传入格式化字符串 */

   	printf("now str is :%s\n", str);

   	return 0;
}