Adds another line to the request using a plain hash.

 The line should be provides as a hash of the fields parsed from the line.
187788
def add_line_hash(value_hash)
      @lines << value_hash
      if value_hash[:compound]
        value_hash.each do |key, value|
          if value_hash[:compound].include?(key)
            @attributes[key] = [] if @attributes[key].nil?
            @attributes[key] = [@attributes[key]] unless @attributes[key].is_a?(Array)
            @attributes[key] << value
          else
            @attributes[key] = value unless key == :compound || @attributes[key]
          end
        end
      else
        @attributes = value_hash.merge(@attributes)
      end
    end
899489
def str_append_hash(*args):
    
    ret_hash = ""
    for i in args:
        ret_hash += str(i).lower()

    return hash(ret_hash)
736933
def add_marks(marks=nil)
      marks.each_pair {|k,v| self[k]=v} if marks
      if block_given?
        result = yield self
        add_marks(result) if Hash===result
      end
    end
527282
def parse_line(line, &block) # :yields: request
      if request_data = file_format.parse_line(line) { |wt, message| warn(wt, message) }
        @parsed_lines += 1
        update_current_request(request_data.merge(source: @current_source, lineno: @current_lineno), &block)
      end
    end
492103
def request(method, path, params={}, body=nil, headers={}, options={}, &block)
      options = { :mashify => true }.merge(options)
      req = http.build_request(method)
      req.path = path
      req.params.update(Util.clean_params(params)) if params
      req.body = body
      req.headers.update(headers) if headers
      block.call(req) if block
      logger.debug { Util.curl_format(req) }

      if @http_threadsafe
        env = req.to_env(http)
        check_response(http.app.call(env), options)
      else
        @request_mtx.synchronize {
          env = req.to_env(http)
          check_response(http.app.call(env), options)
        }
      end
    end
607951
def add(self, field, op=None, val=None):
        
        if field.has_subfield():
            self._fields[field.full_name] = 1
        else:
            self._fields[field.name] = 1
        if op and op.is_size() and not op.is_variable():
            # get minimal part of array with slicing,
            # but cannot use slice with variables
            self._slices[field.name] = val + 1
        if op and op.is_variable():
            # add the variable too
            self._fields[val] = 1
1355592
def addfield(self, pkt, s, val):
        """"""
        if self.adjust(pkt, self.length_of) == 2:
            return s + struct.pack(self.fmt[0] + "H", val)
        elif self.adjust(pkt, self.length_of) == 8:
            return s + struct.pack(self.fmt[0] + "Q", val)
        else:
            return s
1341210
def put(path, options={}, raw=false, unformatted=true)
      request(:put, path, options, raw, unformatted)
    end
522914
def add_hashed_value(self, hash_value, store_key):
        
        if self._unique and hash_value in self._index:
            raise NonUnique('Hash value {} already in index'.format(hash_value))
        if store_key not in self._index[hash_value]:
            self._index[hash_value].append(store_key)
        if hash_value not in self._reverse_index[store_key]:
            self._reverse_index[store_key].append(hash_value)
46326
def add_line(self, line, source, *lineno):
        """"""
        self.result.append(line, source, *lineno)
396773
def do_request(self, line):
        

        def f(p, method, params):
            result = p.call(method, params)
            print("RESULT %s" % result)

        self._request(line, f)
1137234
def add_field(title, value, short=true)
        fields.push({:title => title, :value => value, :short => short })
    end
511157
def post(path, options={}, raw=false, unformatted=true)
      request(:post, path, options, raw, unformatted)
    end
339967
def add_field(self, field):
        
        field = FieldFactory(
            field,
        )
        field.set_table(self)

        # make sure field is not already added
        field_name = field.get_name()
        for existing_field in self.fields:
            if existing_field.get_name() == field_name:
                return None

        self.before_add_field(field)
        field.before_add()

        if field.ignore is False:
            self.fields.append(field)

        return field
950065
def insert_line(self, line):
        """"""
        if self.current_block is not None:
            self.current_block.append(line)
        else:
            self.header.append(line)
524609
def add_hash(self, value):
        
        self.leaves.append(Node(codecs.decode(value, 'hex_codec'), prehashed=True))
352448
def add_fields(self, **fields):
        
        query = {}
        for field in fields:
            query[field] = fields[field]
        self._q.append({'$addFields': query})
        return self