anchor.diff:  %%--------------------------------------------------------------------
   -spec handle_call(Request :: term(),
   		  From :: {pid(), Tag :: term()},
  -		  State :: #state{}) ->
  +		  State :: #{}) ->
       {reply, Reply, State} |
       {reply, Reply, State, Timeout} |
       {noreply, State} |
       {noreply, State, Timeout} |
       {stop, Reason, Reply, State} |
       {stop, Reason, State}.
  -handle_call({create_table, TableName, KeyDef, Options}, From, State) ->
  -    P = #'CreateTable'{table_name = TableName,
  -		       keys = KeyDef,
  -		       table_options = make_set_of_table_option(Options)},
  -    send_request({create_table, P}, From, State);
  -handle_call({delete_table, TableName}, From, State) ->
  -    P = #'DeleteTable'{table_name = TableName},
  -    send_request({delete_table, P}, From, State);
  -handle_call({open_table, TableName}, From, State) ->
  -    P = #'OpenTable'{table_name = TableName},
  -    send_request({open_table, P}, From, State);
  -handle_call({close_table, TableName}, From, State) ->
  -    P = #'CloseTable'{table_name = TableName},
  -    send_request({close_table, P}, From, State);
  -handle_call({table_info, TableName}, From, State) ->
  -    P = #'TableInfo'{table_name = TableName},
  -    send_request({table_info, P}, From, State);
  -handle_call({table_info, TableName, Attributes}, From, State) ->
  -    P = #'TableInfo'{table_name = TableName,
  -		     attributes = Attributes},
  -    send_request({table_info, P}, From, State);
  -handle_call({read, TableName, Key}, From, State) ->
  -    P = #'Read'{table_name = TableName,
  -		key = make_seq_of_fields(Key)},
  -    send_request({read, P}, From, State);
  -handle_call({write, TableName, Key, Columns}, From, State) ->
  -    P = #'Write'{table_name = TableName,
  -		 key = make_seq_of_fields(Key),
  -		 columns = make_seq_of_fields(Columns)},
  -    send_request({write, P}, From, State);
  -handle_call({update, TableName, Key, Op}, From, State) ->
  -    P = #'Update'{table_name = TableName,
  -		  key = make_seq_of_fields(Key),
  -		  update_operation = make_update_operations(Op)},
  -    send_request({update, P}, From, State);
  -handle_call({delete, TableName, Key}, From, State) ->
  -    P = #'Delete'{table_name = TableName,
  -		  key = make_seq_of_fields(Key)},
  -    send_request({delete, P}, From, State);
  -handle_call({read_range, TableName, StartKey, EndKey, Chunk}, From, State) ->
  -    P = #'ReadRange'{table_name = TableName,
  -		     start_key = make_seq_of_fields(StartKey),
  -		     end_key = make_seq_of_fields(EndKey),
  -		     limit = Chunk},
  -    send_request({read_range, P}, From, State);
  -handle_call({read_range_n, TableName, StartKey, N}, From, State) ->
  -    P = #'ReadRangeN'{table_name = TableName,
  -		      start_key = make_seq_of_fields(StartKey),
  -		      n = N},
  -    send_request({read_range_n, P}, From, State);
  -handle_call({batch_write, TableName, DeleteKeys, WriteKvls}, From, State) ->
  -    P = #'BatchWrite'{table_name = TableName,
  -		      delete_keys = make_keys(DeleteKeys),
  -		      write_kvps = make_kvls(WriteKvls)},
  -    send_request({batch_write, P}, From, State);
  -handle_call({first, TableName}, From, State) ->
  -    P = #'First'{table_name = TableName},
  -    send_request({first, P}, From, State);
  -handle_call({last, TableName}, From, State) ->
  -    P = #'Last'{table_name = TableName},
  -    send_request({last, P}, From, State);
  -handle_call({seek, TableName, Key}, From, State) ->
  -    P = #'Seek'{table_name = TableName,
  -		key = make_seq_of_fields(Key)},
  -    send_request({seek, P}, From, State);
  -handle_call({next, It}, From, State) ->
  -    P = #'Next'{it = It},
  -    send_request({next, P}, From, State);
  -handle_call({prev, It}, From, State) ->
  -    P = #'Prev'{it = It},
  -    send_request({prev, P}, From, State);
  +handle_call(get_state, _From, State) ->
  +    {reply, State, State};
   handle_call(_Request, _From, State) ->
       ?notice("Unhandled gen_server Request: ~p, From ~p, State: ~p",
   	    [_Request, _From, State]),
  
positive.code: -spec delete_table(Session :: pid(), TabName :: string())->
      ok | {error, Reason :: term()}.
  delete_table(Session, TabName) ->
      Data = gen_server:call(Session, {delete_table, TabName}, ?REQ_TIMEOUT),
      decode(Data).
  
  %%--------------------------------------------------------------------
  %% @doc
  
negative.code: 	{ok, Socket} ->
  	    ssl:setopts(Socket, [{packet, 4}]),
  	    TR = ets:new(transaction_register, [set, public, {keypos, 1}]),
  	    Counter = ets:new(counter, [set, public]),
  	    ets:insert(Counter, {transaction_id, ?TID_THRESHOLD}),
  	    {ok, #{socket => Socket,
  		   transaction_register => TR,
  		   counter => Counter,
  		   timeout => ?REQ_TIMEOUT,
  		   monitor_ref => MonitorRef}};
  	{error, _Reason} ->
  	    {stop, normal}
      end.
  