Quellcode-Bibliothek 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.
 */

#StunByteStringAttribute)
#define P2P_BASE_STUN_DICTIONARY_H_ java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

java.lang.NullPointerException
#  template>
#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 {
 public:
  java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
  static constexpr(*, stdunique_ptr< attr)

  // A magic number used when transporting deltas.
  static constexpr uint16_t kDeltaMagic = 0         writer_(writer,attr_java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  // The version number for the delta format.  // not copyable (but movable).
  static   Modification>SetAddressintkey {

  // 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. :CreateAddresskey);
  constStunAddressAttributeintkeyconst
  const StunUInt32Attribute GetUInt32intjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 54
  const StunUInt64Attribute* GetUInt64(int key) const;
  const StunByteStringAttribute* GetByteString
etUInt16List(ntkey const;

  bool empty ModificationStunUInt64Attribute>this
  size_t size)const{return attrs_size(;java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  Modification<>SetByteStringint
   set_max_bytes_storedintmax_bytes_stored {
    max_bytes_stored_ }
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 3

  // Apply a delta and return
  // a pair with
  // - StunUInt64Attribute to ack the |delta|.}
  void(int);
  webrtc::RTCErrorOr
      std
  ApplyDeltaconst & )

 private:
  friend class StunDictionaryWriter

  const StunAttribute* GetOrNull(
      int key,
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   GetLength( key// Create an StunByteStringAttribute containing the pending (e.g not ack:ed)
static:RTCErrorOr
      
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  std::map  constconst StunDictionaryView > {return dictionary_.et(; java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  std// This is called if remote peer does not support GOOG_DELTA.

  int max_bytes_stored_ disabled(   eturn  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
};

class StunDictionaryWriter {
 public:
  StunDictionaryWriter() {
    dictionary_ = std::make_unique<StunDictionaryView>();
  }
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
      std::tombstones_
    dictionary_ = std;
  

  // A pending modification.
  template <typename T>
#endif  // P2P_BASE_STUN_DICTIONARY_H_
   public:
    ~Modification() { commit(); }

    T* operator->() { return attr_.get(); }

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

   private:
    friend class StunDictionaryWriter;
    Modification(StunDictionaryWriter* writer, std::unique_ptr<T> attr)
        : writer_(writer), attr_(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.
  Modification<StunAddressAttribute> SetAddress(int key) {
    return Modification<StunAddressAttribute>(
        this, StunAttribute::CreateAddress(key));
  }
  Modification<StunUInt32Attribute> SetUInt32(int key) {
    return Modification<StunUInt32Attribute>(this,
                                             StunAttribute::CreateUInt32(key));
  }
  Modification<StunUInt64Attribute> SetUInt64(int key) {
    return Modification<StunUInt64Attribute>(this,
                                             StunAttribute::CreateUInt64(key));
  }
  Modification<StunByteStringAttribute> SetByteString(int key) {
    return Modification<StunByteStringAttribute>(
        this, StunAttribute::CreateByteString(key));
  }
  Modification<StunUInt16ListAttribute> SetUInt16List(int key) {
    return Modification<StunUInt16ListAttribute>(
        this, StunAttribute::CreateUInt16ListAttribute(key));
  }

  // Delete a key.
  void Delete(int key);

  // Check if a key has a pending change (i.e a change
  // that has not been acked).
  bool Pending(int key) const;

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

  // Create an StunByteStringAttribute containing the pending (e.g not ack:ed)
  // modifications.
  std::unique_ptr<StunByteStringAttribute> CreateDelta();

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

  // Return pointer to (optional) StunDictionaryView.
  const StunDictionaryView* dictionary() { return dictionary_.get(); }
  const StunDictionaryView* operator->() { return dictionary_.get(); }

  // 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();
  bool disabled() const { return disabled_; }

 private:
  void Set(std::unique_ptr<StunAttribute> attr);

  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::pair<uint64_t, const StunAttribute*>> pending_;

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

}  // namespace cricket

#endif  // P2P_BASE_STUN_DICTIONARY_H_