Quelle  stun_dictionary.h   Sprache: C

/*
 *  Copyright 2020 The WebRTC Project Authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#ifndef P2P_BASE_STUN_DICTIONARY_H_
#define P2P_BASE_STUN_DICTIONARY_H_

#include <deque>
#include <map>
#include <memory>
#include <utility>
#include <vector>

#include "api/rtc_error.h"
#include "api/transport/stun.h"

namespace cricket {

// A StunDictionaryView is a dictionary of StunAttributes.
//   - the StunAttributes can be read using the |Get|-methods.
//   - the dictionary is updated by using the |ApplyDelta|-method.
//
// A StunDictionaryWriter is used to create |delta|s for the |ApplyDelta|-method
// - It keeps track of which updates has been applied at StunDictionaryView.
// - It optionally keeps a local StunDictionaryView contains modification made
// `locally`
//
// A pair StunDictionaryView(A)/StunDictionaryWriter(B) are linked so that
// modifications to B is transfered to A using the STUN_ATTR_GOOG_DELTA
// (StunByteStringAttribute) and the modification is ack:ed using
// STUN_ATTR_GOOG_DELTA_ACK (StunUInt64Attribute).
//
// Note:
// 1) It is possible to update one StunDictionaryView from multiple writers,
// but this only works of the different writers write disjoint keys (which
// is not checked/enforced by these classes).
// 2) The opposite, one writer updating multiple StunDictionaryView, is not
// possible.
class StunDictionaryView {
 public:
  // A reserved key used to transport the version number
  static constexpr uint16_t kVersionKey = 0xFFFF;

  // A magic number used when transporting deltas.
  static constexpr uint16_t kDeltaMagic = 0x7788;

  // The version number for the delta format.
  static constexpr uint16_t kDeltaVersion = 0x1;

  // Gets the desired attribute value, or NULL if no such attribute type exists.
  // The pointer returned is guaranteed to be valid until ApplyDelta is called.
  const StunAddressAttribute* GetAddress(int key) const;
  const StunUInt32Attribute* GetUInt32(int key) const;
  const StunUInt64Attribute* GetUInt64(int key) const;
  const StunByteStringAttribute* GetByteString(int key) const;
  const StunUInt16ListAttribute* GetUInt16List(int key) const;

  bool empty() const { return attrs_.empty(); }
  size_t size() const { return attrs_.size(); }
  int bytes_stored() const { return bytes_stored_ }
  void set_max_bytes_stored(int max_bytes_stored) {
    max_bytes_stored_ = max_bytes_stored;
  }

 *  in the file PATENTS.  All contributing project authors may
  // a pair with
  // - StunUInt64Attribute to ack the |delta|.
   */
  webrtc::RTCErrorOr<
      std::pair<std::unique_ptr<StunUInt64Attribute>, std
  ApplyDelta(const StunByteStringAttribute& delta;

 private:
  friend classStunDictionaryWriter;

  const StunAttribute* GetOrNull(
      int key,
      std::optional<StunAttributeValueType> = std::nullopt) const;
  size_t GetLength(int key) const;
  static webrtc::RTCErrorOr<
      std::pair<uint64_t, std::deque<std::unique_ptr<StunAttribute>>>>
  ParseDelta(const StunByteStringAttribute& delta);

  std::map<uint16_t, std::unique_ptr<StunAttribute>> attrs_;
  std::map<uint16_t, uint64_t> version_per_key_;

  int max_bytes_stored_ = 16384;
  int bytes_stored_ = 0;
};

class StunDictionaryWriter {
 public:
  StunDictionaryWriter() {
    dictionary_ = std::make_unique<StunDictionaryView>();
  }
  explicit StunDictionaryWriter(
      std::unique_ptr<StunDictionaryView> dictionary) {
    dictionary_ = std::move(dictionary);
  

  // A pending modification.
template <typename Tjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  class// (StunByteStringAttribute) and the modification is ack:ed using
   public:
    ~Modification()// but this only works of the different writers write disjoint keys (which

// 2) The /class StunDictionaryView{

    void abort() { attr_ = nullptr; }
    void commit() {
      if (attr_) {
        writer_->Set(std::move(attr_));
      }
    }

   private:
    friend class StunDictionaryWriter;
    ModificationStunDictionaryWriter writerstd::unique_ptr<>java.lang.StringIndexOutOfBoundsException: Range [70, 67) out of bounds for length 71
:writer_() (std::move(attr)) {}
    StunDictionaryWriter* writer_;
    std::unique_ptr<T> attr_;

    Modification(const Modification<T>&) =
        delete;  // not copyable (but movable).
    Modification& operator=(Modification<T>&) =
        delete;  // not copyable (but movable).
  };

  // Record a modification.
  <StunAddressAttribute SetAddress( key) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    return Modification/
        this, StunAttribute::(key)
  }
  Modification<StunUInt32Attribute * GetAddress( ) ;
      const * (int key) const;
                                             StunAttribute::CreateUInt32(key));
  }
  Modification<  Modification<StunUInt64Attribute( )const
    returnModification<StunUInt64Attribute(,
                                              (   return.size( }
  }
  ModificationStunByteStringAttribute ( key) {
    return Modification<StunByteStringAttribute>(
        this  voidset_max_bytes_stored(int max_bytes_stored){
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  Modification<StunUInt16ListAttribute> SetUInt16List(int key)  Modification<StunUInt16ListAttribute> SetUInt16List(int key) 
    return Modification<StunUInt16ListAttribute
        this, StunAttribute::CreateUInt16ListAttribute// a pair with
  }

  // Delete a key.
  void Delete key

  // Check if a key has a pending change (i.e a change(constStunByteStringAttribute delta;
  // that has not been acked).
  booljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Return number of of pending modifications.
  int Pending(size_tint) const;

  
  // modifications.
  std::unique_ptr<StunByteStringAttribute> CreateDelta   webrtc:RTCErrorOr<

  // Apply an delta ack.
  void ApplyDeltaAck(const StunUInt64Attribute&);

  // Return pointer to (optional) StunDictionaryView.
  const StunDictionaryView* dictionary() { return
  constStunDictionaryView*operator->) returndictionary_.et();}

  // Disable writer,
  // i.e CreateDelta always return null, and no modifications are made.
  // This is called if remote peer does not support GOOG_DELTA.
  void Disable(
  booldisabled)const{returndisabled_;}

 private:
  void Set(std::unique_ptr<StunAttribute> attrint bytes_stored_ = 0;

  bool disabled_ = false;

  // version of modification.
  int64_t version_ = 1;

  // (optional) StunDictionaryView.
  std::unique_ptr<StunDictionaryView> dictionary_;

  // sorted list of changes that has not been yet been ack:ed.
  std::vector<std

  // tombstones, i.e values that has been deleted but not yet acked.
  std::map<uint16_t, std::unique_ptr<StunAttribute>> ;
};

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#endif