telecom/entry_pool.cpp at master · zwparchman/telecom · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include "entry_pool.h"
#include <bitset>
uint64_t entry_pool::get_phone_number( size_t i ){
  return tag[i]>>(1+2+7+5);
}

uint8_t entry_pool::get_service_area_code( size_t i ){
  return (tag[i]>>(1+2+7)) &0b11111;
}

bool entry_pool::is_active( size_t i){
  return tag[i] & 1;
}

uint8_t entry_pool::get_prefrences(size_t i){
  uint8_t ret= (tag[i]>>(1+2) & 0b111'1111);
  return ret;
}

uint8_t entry_pool::get_phone_type(size_t i){
  return (tag[i]>>1) & 0b11;
}

void entry_pool::self_sort(){
  sorted = true;
  __gnu_parallel::sort(tag.begin(), tag.end());
}

size_t entry_pool::getNumber_index( uint64_t goal ){
  if( !sorted ) self_sort();

  const int shift = 1+2+7+5;
  auto where = std::lower_bound( tag.begin(), tag.end(), goal << shift);

  if(where == tag.end()) return size();

  size_t ret = where - tag.begin();

  if( get_phone_number( ret) == goal ){
    return ret;
  } else {
    return size();
  }

}

bool entry_pool::has_number( uint64_t phoneNumber ){
  return getNumber_index(phoneNumber) != size();
}

entry_pool::entry_pool( size_t to_reserve ){
  tag.reserve(to_reserve);
}

void entry_pool::add( uint64_t _phoneNumber,
    uint8_t _service_area_code,
    uint8_t _prefrences,
    char _opstype,
    uint8_t _phone_type ){

  uint64_t incoming=0;

  sorted=false;
  incoming |= _phoneNumber;
  incoming <<= 5;
  incoming |= _service_area_code;
  incoming <<= 7;
  incoming |= _prefrences;
  incoming <<= 2;
  incoming |= _phone_type;
  incoming <<= 1;
  incoming |= _opstype == 'A';

  tag.push_back( incoming );
}

char entry_pool::get_ops_type(size_t i){
  return ( (tag[i] & 1)?'A':'D');
}

size_t entry_pool::size() const {
  return tag.size();
}

std::string entry_pool::prefrences_to_string( uint8_t pref){
  const std::bitset<8> set(pref);
  if( pref == 0 ){
    return "";
  }

  std::cout<<set.to_string()<<std::endl;

  std::string ret="";
  for( int i=0; i<7; i++){
    if( set[i] ){
      ret+=std::to_string(1+i)+"#";
    }
  }
  ret.erase( ret.end()-1, ret.end());

  return ret;
}


void entry_pool::merge( entry_pool &a, entry_pool &b){
  if( !a.sorted) a.self_sort();
  if( !b.sorted) b.self_sort();
  ao::uvector<uint64_t> c;
  c.resize( a.tag.size() + b.tag.size());
  __gnu_parallel::merge(
      a.tag.begin(), a.tag.end(),
      b.tag.begin(), b.tag.end(),
      c.begin());

  a.sorted=true;
  a.tag = move(c);
}