让程序中的简单if-else在编译期间决定

ex. 1 /*

 2  * =====================================================================================
 3  *
 4  *       Filename:  3.cpp
 5  *
 6  *    Description:  
 7  *
 8  *        Version:  1.0
 9  *        Created:  03/01/2016 11:38:53 AM
10  *       Revision:  none
11  *       Compiler:  gcc
12  *
13  *         Author:  shih (Hallelujah), sh19871122@gmail.com
14  *   Organization:  
15  *
16  * =====================================================================================
17  */
18 
19 #include <stdio.h>
20 #include <stdint.h>
21 #include <iostream>
22 #include <type_traits>
23 
24 template<typename T>
25 struct is_swapable
26 {
27     static const bool value = std::is_integral<T>::value && sizeof(T) >= 2;
28 };
29 
30 template<typename T>
31 T byte_swap(T value, std::true_type)
32 {
33    uint8_t *bytes = reinterpret_cast<uint8_t *>(&value);
34    for (std::size_t i = 0; i < sizeof(T)/2; ++i)
35    {   
36        uint8_t v = bytes[i];
37        bytes[i] = bytes[sizeof(T) - 1 - i]; 
38        bytes[sizeof(T) -1 -i] = v;
39    }   
40    return value;
41 }
42 
43 template<typename T>
44 T byte_swap(T value, std::false_type)
45 {
46     return value;
47 }
48 
49 template<typename T>
50 T byte_swap(T value)
51 {
52     return byte_swap(value, std::integral_constant<bool, is_swapable<T>::value>());
53 }
54 
55 int main(int argc, const char *argv[])
56 {
57     int a = 0x11223344;
58     long b = 0x4455221112345678;
59     std::cout << std::hex << a << " " << b << std::endl;
60     std::cout << std::hex << byte_swap(a) << " " << byte_swap(b) << std::endl;
61     uint8_t c = 0x11;
62     char *d = "hello world";
63     std::cout << std::hex << byte_swap(c) << " " << byte_swap(d) << std::endl;
64     return 0;
65 }
66 

package jsl.hive.udf;

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public final class DomainRoot extends UDF {
    public Text evaluate(Text s) {
        if (s == null) {return null;}
        String tmp = s.toString();
        tmp = this.getDomainRoot(tmp);
        return new Text(tmp);
    }   

    private String getDomainRoot(String domain) {
        throw NoneImplementException("xxxx");
    }   
}

ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java中加入

template<typename D, typename B>
struct must_have_base
{
    ~must_have_base()
    {
        void (*p)(D*, B*) = constraints;
    }

private:
    static void constraints(D *pd, B *pb)
    {
        pb = pd;
    }
};
原理是通过不执行的成员函数把函数指针在析构函数中赋值，强迫编译器在编译期间检查成员函数内的约束。  

 1 
 2 template<typename D, typename B>
 3 struct must_have_base
 4 {
 5     ~must_have_base()
 6     {
 7         void (*p)(D*, B*) = constraints;
 8     }
 9 
10 private:
11     static void constraints(D *pd, B *pb)
12     {
13         pb = pd;
14     }
15 };
16 
17 class base
18 {
19 public:
20     virtual ~base() {}
21 
22     virtual void run() = 0;
23 };
24 
25 class inherit_base: public base
26 {
27 public:
28     virtual void run()
29     {
30 
31     }
32 };
33 
34 class inherit_not_base 
35 {
36 public:
37     virtual void run()
38     {
39 
40     }
41 };
42 
43 class test
44 {
45 public:
46     template<typename T>
47     void testfunc(T &t)
48     {
49         must_have_base<T, base>();
50 
51         t.run();
52     }
53 };
54 
55 int main()
56 {
57     test t_ok, t_nok;
58     inherit_base hb;
59     inherit_not_base hnb;
60     t_ok.testfunc(hb);
61     t_nok.testfunc(hnb);
62 
63     return 0;
64 }

 1 
 2 # -*- coding:utf-8 -*-
 3 #/user/bin/env python
 4 
 5 __author__ = 'shih'
 6 
 7 from kivy.app import App
 8 
 9 class Hello(App):
10     pass
11 
12 if __name__ == "__main__":
13     Hello().run()

不知道里面怎么弄表格，就上传图片了

如果用户自定义的类，想有add功能，如果类没提供__add__或__radd__方法的话，会抛出异常
再如，if xxxobj:默认是如果xxxobj不是None则为True，否则为False，如果不是这个逻辑则可以通过实现__bool__方法(自己的测试中2.7需要再加上__nonzero__()方法，3.2中直接就行)

 1 def args_unpacking_test(x, y):
 2     print 'x = ', x, ' y = ', y
 3 
 4 A = namedtuple('A', 'y x')
 5 
 6 list_foo = [3, 4]
 7 tuple_foo = (3, 4)
 8 ntuple_foo = A(4, 3)
 9 dict_foo = {'y':4, 'x':3}
10 
11 
12 args_unpacking_test(*list_foo)
13 args_unpacking_test(*tuple_foo)
14 args_unpacking_test(*ntuple_foo)
15 args_unpacking_test(**dict_foo)
16 
17 他们的结果输出都是一样的

这个方式处理非常有用，如果参数个数不一致的话会报错