impl Solution {

    pub fn max_abs(a:i32,b:i32) -> i32 {

        if a <0{
            a= -a
        }
        if b<0{
            b= -b
        }

        if a > b {
            a     
        }else{
            b 
        }
    }

    pub fn max_absolute_sum(nums: Vec<i32>) -> i32 {
        let mut res = 0;

        let mut dp_max = vec![0;nums.length()];
        let mut dp_min = vec![0;nums.length()];
        
        for (i,num) in nums.iter().enumerate() {
            if i == 0 {
                dp_max[0] = *num
                dp_min[0] = *num 
                res = Solution::max_abs(dp_max[0],dp_min[0])
            }else{
                let max_num = dp_max[i-1] + *num
                if max_num > *num{
                    dp_max[i] = max_num
                }else{
                    dp_max[i] =*num
                }

                let min_num = dp_min[i-1] + *num
                if min_num < *num{
                    dp_min[i] = min_num
                }else{
                    dp_min[i] = *num
                }
                
                max_num = Solution::max_abs(dp_max[i],dp_min[i]) 
                res = Solution::max_abs(max_num,res)
            }
        }
        res
    }
}

error: expected `;`, found `dp_min`
  --> src/main.rs:60:33
   |
60 |                 dp_max[0] = *num
   |                                 ^ help: add `;` here
61 |                 dp_min[0] = *num 
   |                 ------ unexpected token

|         let mut dp_max = vec![0;nums.length()];
|                                      ^^^^^^ help: there is a method with a similar name: `len`

34 | impl Solution {
   |      ^^^^^^^^ not found in this scope

pub fn max_absolute_sum(nums: Vec<i32>) -> i32 {
   |            ----------------                    ^^^ expected `i32`, found `()`
   |            |
   |            implicitly returns `()` as its body has no tail or `return` expression
...
87 |         res;
   |            - help: remove this semicolon to return this value

pub fn max_absolute_sum(nums: Vec<i32>) -> i32 {
   |            ----------------                    ^^^ expected `i32`, found `()`
   |            |
   |            implicitly returns `()` as its body has no tail or `return` expression
...
87 |         res;
   |            - help: remove this semicolon to return this value

70 |                 let max_num = dp_max[i-1] + *num;
   |                     -------
   |                     |
   |                     first assignment to `max_num`
   |                     help: consider making this binding mutable: `mut max_num`
...
84 |                 max_num = Solution::max_abs(dp_max[i],dp_min[i]);
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable

struct Solution{

}


impl Solution {

    pub fn max_abs(a:i32,b:i32) -> i32 {
        let mut a = a ;
        let mut b = b ;
        if a <0{
            a= -a;
        }
        if b<0{
            b= -b;
        }

        if a > b {
            a     
        }else{
            b 
        }
    }

    pub fn max_absolute_sum(nums: Vec<i32>) -> i32 {
        let mut res = 0;

        let mut dp_max = vec![0;nums.len()];
        let mut dp_min = vec![0;nums.len()];
        
        for (i,num) in nums.iter().enumerate() {
            if i == 0 {
                dp_max[0] = *num;
                dp_min[0] = *num;
                res = Solution::max_abs(dp_max[0],dp_min[0])
            }else{
                let mut max_num = dp_max[i-1] + *num;
                if max_num > *num{
                    dp_max[i] = max_num;
                }else{
                    dp_max[i] =*num;
                }

                let min_num = dp_min[i-1] + *num;
                if min_num < *num{
                    dp_min[i] = min_num;
                }else{
                    dp_min[i] = *num;
                }
                
                max_num = Solution::max_abs(dp_max[i],dp_min[i]);
                res = Solution::max_abs(max_num,res);
            }
        }
        res
    }
}


fn main(){
    Solution::max_absolute_sum(vec![1,-3,2,3,-4]);
}

//f(n) 绝对值最大 = n 的 最大值和最小值的绝对值取大
// f(n) 最大值 = f(n-1) 的最大值+n 和 n 取大
// f(n) 最小值 = f(n-1) 的最小值+n  和 n 取小

impl Solution {
    pub fn max_absolute_sum(nums: Vec<i32>) -> i32 {
        let n = nums.len();
        let mut res = 0;

        let mut dp_max = 0;
        let mut dp_min = 0;
        
        for i  in 0..n {
            if i == 0 {
                dp_max = nums[0];
                dp_min = nums[0]; 
                res = dp_max.abs().max(dp_min.abs());
            }else{
                
                let  max_num = dp_max + nums[i];
                dp_max = max_num.max(nums[i]); 

                let  min_num = dp_min + nums[i];
                dp_min = min_num.min(nums[i]); 
                
                res = res.max(dp_max.abs().max(dp_min.abs())); 

            }
        } 
        res
    }
}

let greeting_file = File::open("hello.txt").unwrap();

let mut f = match f {
    // 打开文件成功，将file句柄赋值给f
    Ok(file) => file,
    // 打开文件失败，将错误返回(向上传播)
    Err(e) => return Err(e),
};

cpan Test::Nginx

use Test::Nginx::Socket 'no_plan';

run_tests;

__DATA__

=== TEST 1: max pool size is 200
--- http_config eval: $::HttpConfig
--- config
    location /t {
        content_by_lua_block {
          ngx.print("hello world")   
        }
    }

--- request
GET /t

--- response_body chomp
hello world

# 调用对应的测试模块 一般使用 'no_plan' 即可
use Test::Nginx::Socket 'no_plan';
# 运行测试用例 
run_tests;

--- config
location = /t {
    echo "hello, world!";
}

--- request
GET /t

--- response_body
hello, world!

--- error_code: 200

# chomp : 去掉换行符
--- error_code chomp  
200

# eval: 执行一个 Perl 代码 :以下是生产 4096 个 a 字符串的body . 
--- response_body eval
"a" x 4096

export PATH=/usr/local/openresty/nginx/sbin:$PATH

#!/usr/bin/env bash

export PATH=/usr/local/Cellar/openresty/1.21.4.2_1/nginx/sbin:$PATH

# 部分系统perl环境会提示(Can't locate t/.pm in @INC)
export PERL5LIB=$(pwd):$PERL5LIB

exec prove "$@"

$ ./go.sh t/aa.t 
t/aa.t .. ok   
All tests successful.
Files=1, Tests=2,  0 wallclock secs ( 0.02 usr  0.01 sys +  0.19 cusr  0.10 csys =  0.32 CPU)
Result: PASS

t/000-sanity.t
t/001-set.t
t/002-content.t
t/003-errors.t
...
t/139-ssl-cert-by.t

use Test::Nginx::Socket 'no_plan';

no_shuffle();
run_tests();

__DATA__
...

export TEST_NGINX_INIT_BY_LUA="package.path = '$PWD/../lua-resty-core/lib/?.lua;' .. (package.path or '') require 'resty.core'"

use Test::Nginx::Socket::Lua;
 
repeat_each(2);
plan tests => repeat_each() * 3 * blocks();
 
no_shuffle();
run_tests();
 
__DATA__
 
=== TEST 1: sanity
--- config
    location = /t {
        content_by_lua '
            ngx.say("hello world")
        ';
    }
--- request
    GET /t
--- response_body
hello world
--- error_code: 200
--- no_error_log
[error]

stream {
    server {
        listen 1985;
        echo "Hello, stream echo!";
    }
}

stream {
    server {
        listen 1985 udp;
        echo "Hello, stream echo!";
    }
}

KeyIndex.new(shared_dict, prefix)
  self.dict = shared_dict
  self.key_prefix = prefix .. "key_"
  self.delete_count = prefix .. "delete_count"
  self.key_count = prefix .. "key_count"
  self.last = 0
  self.deleted = 0
  self.keys = {}
  self.index = {}

KeyIndex:sync() 
   获取 dict delete_count 和 dict key数量 N
   如果本地的 delete  和 delete_count 不同,说明有删除
     执行 sync_range(0,N)
   如果当前的 last 和 N 不同说明有更新，那么执行 sync_reange(N,last) 
   并返回 N

KeyIndex:sync_range(first, last) 
   从 dict 同步 first 到 last 区间的内容到当前对象
      从 dict 获取 keyi 
      记录映射关系 keys[i] = key ,index[key]=i     
   如果 keyi 是不存在的，从映射关系删除内容

KeyIndex:list() 
   执行同步 sync()
   并返回 keys 的 copy

KeyIndex:add(key_or_keys, err_msg_lru_eviction) 
   对每一个 key 执行：
      同步并获取N
      如果 key 存在，就跳过
      如果 key 不存在就设置 dict N+1 为 key 
           key_count ++ 
           设置 keys 和 index 
           
KeyIndex:remove(key, err_msg_lru_eviction)
   

总结：
利用 dict 存储数据，利用 sync 将数据同步到 worker 进程的函数

register(self, name, help, label_names, buckets, TYPE_HISTOGRAM)
	   构建指标需要的数据，对传入的name 去掉 _bucket _sum _count 的后缀
    当为 historgram 时 name 或 name_maybe_historgram 存在
    当为其他时， name 或者加入了后缀的存在都认为是指标存在，返回错误。 
    label_names ：label 名列表
    label_count： label 数量
    lookup = {} :用table 来存储指标树 
      例如 ['me.com']['200'][LEAF_KEY] = 'http_count{host="me.com",status="200"}' 
   
yield :执行读写 dict 次数 200 次就释放一次 cpu 时间片占用

lookup_or_create(self, label_values) 
   返回完整的指标名 counter 和 gauge 直接返回字符串
   histogram 返回 list 
   如果 lookup_size > lookup_max_size ,清空 lookup
inc_gauge: dict incr 
   
 

local get_var      = require("resty.ngxvar").fetch   
local get_request  = require("resty.ngxvar").request  

function _M.fetch(name, request)
    -- 从 vars 获取值，var 实现了 ffi 获取 uri  host  remote_addr request_time scheme upstream_response_time 等
    local method = vars[name]
    
    -- 未实现的直接从 ngx_var 取值 
    if not var_patched or not method then
        if num_type[name] then
            return tonumber(ngx_var[name])
        elseif ups_num_type[name] then
            return sum_upstream_num(ngx_var[name])
        end

        return ngx_var[name]
    end

    return method(request)
end

type TrieNode struct {
    // Value rune 
    Iskey bool
    Next map[rune]*TrieNode 
}

type RedixNode struct {
    Value string 
    Iskey bool
    Next map[rune]*RedixNode 
}

typedef struct raxNode {
    uint32_t iskey:1;     /* Does this node contain a key? */
    uint32_t isnull:1;    /* Associated value is NULL (don't store it). */
    uint32_t iscompr:1;   /* Node is compressed. */
    uint32_t size:29;     /* Number of children, or compressed string len. */
    unsigned char data[];
} raxNode;

*
*                    (f) ""
*                    /
*                 (i o) "f"
*                 /   \
*    "firs"  ("rst")  (o) "fo"
*              /        \
*    "first" []       [t   b] "foo"
*                     /     \
*           "foot" ("er")    ("ar") "foob"
*                    /          \
*          "footer" []          [] "foobar"

/* 对齐函数 ： 在申请内存时对齐到整数倍的字节 
sizeof(void*) 一个指针所占用的内存大小，4个字节或8个字节
nodesize +4   字节数+ 头部占用的32bit（4个字节） 
(nodesize+4) % sizeof(void*)  对整体占用求余
(sizeof(void*)-1) ：前面的已经是padding数了。这里做一个并集。？？
*/
#define raxPadding(nodesize) ((sizeof(void*)-((nodesize+4) % sizeof(void*))) & (sizeof(void*)-1))

void raxSetData(raxNode *n, void *data) {
    n->iskey = 1;
    if (data != NULL) {
        n->isnull = 0;
        void **ndata = (void**)
            ((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
        memcpy(ndata,&data,sizeof(data));
    } else {
        n->isnull = 1;
    }
}
/* Get the node auxiliary data. */
void *raxGetData(raxNode *n) {
    if (n->isnull) return NULL;
    void **ndata =(void**)((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
    void *data;
    memcpy(&data,ndata,sizeof(data));
    return data;
}

// 用来查询字符串在redixtree 中能够匹配到哪个位置
static inline size_t raxLowWalk(rax *rax, unsigned char *s, size_t len, raxNode **stopnode, raxNode ***plink, int *splitpos, raxStack *ts) {
    raxNode *h = rax->head;
    raxNode **parentlink = &rax->head;
    size_t i = 0; /* Position in the string. */
    size_t j = 0; /* Position in the node children (or bytes if compressed).*/
    while(h->size && i < len) {
        debugnode("Lookup current node",h);
        unsigned char *v = h->data;
        if (h->iscompr) {
            for (j = 0; j < h->size && i < len; j++, i++) {
                if (v[j] != s[i]) break;
            }
            if (j != h->size) break;
        } else {
            /* Even when h->size is large, linear scan provides good
             * performances compared to other approaches that are in theory
             * more sounding, like performing a binary search. */
            for (j = 0; j < h->size; j++) {
                if (v[j] == s[i]) break;
            }
            if (j == h->size) break;
            i++;
        }
        if (ts) raxStackPush(ts,h); /* Save stack of parent nodes. */
        raxNode **children = raxNodeFirstChildPtr(h);
        if (h->iscompr) j = 0; /* Compressed node only child is at index 0. */
        memcpy(&h,children+j,sizeof(h));
        parentlink = children+j;
        j = 0; /* If the new node is compressed and we do not
                  iterate again (since i == l) set the split
                  position to 0 to signal this node represents
                  the searched key. */
    }
    debugnode("Lookup stop node is",h);
    if (stopnode) *stopnode = h;
    if (plink) *plink = parentlink;
    if (splitpos && h->iscompr) *splitpos = j;
    return i;
}

void *radix_tree_new();
int radix_tree_destroy(void *t);
int radix_tree_insert(void *t, const unsigned char *buf, size_t len,
    int idx);
void *radix_tree_find(void *t, const unsigned char *buf, size_t len);
void *radix_tree_search(void *t, void *it, const unsigned char *buf, size_t len);
int radix_tree_prev(void *it, const unsigned char *buf, size_t len);
int radix_tree_next(void *it, const unsigned char *buf, size_t len);
int radix_tree_stop(void *it);
void *radix_tree_new_it(void *t);

{
      paths = {"/aa", "/bb*", "/name/:name/*other"},
      hosts = {"*.bar.com", "foo.com"},
      methods = {"GET", "POST", "PUT"},
      remote_addrs = {"127.0.0.1","192.168.0.0/16",
                      "::1", "fe80::/32"},
      vars = {
          {"arg_name", "==", "json"},
          {"arg_weight", ">", 10},
      },
      filter_fun = function(vars, opts)
          return vars["arg_name"] == "json"
      end,

      metadata = "metadata /bb",
  }

function _M.dispatch(self, path, opts, ...)
    ... 
    local route, err = match_route(self, path, opts or empty_table, args)
    ...
    handler(...)
    return true
end