← Back to branch summary

~ubuntu-branches/ubuntu/trusty/protobuf/trusty-proposed

« back to all changes in this revision

Viewing changes to src/google/protobuf/repeated_field.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2011-05-31 14:41:47 UTC
  • mfrom: (2.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110531144147-s41g5fozgvyo462l
Tags: 2.4.0a-2ubuntu1
* Merge with Debian; remaining changes:
  - Fix linking with -lpthread.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/repeated_field.h
72
72
class RepeatedField {
73
73
 public:
74
74
  RepeatedField();
 
75
  RepeatedField(const RepeatedField& other);
75
76
  ~RepeatedField();
76
77
 
 
78
  RepeatedField& operator=(const RepeatedField& other);
 
79
 
77
80
  int size() const;
78
81
 
79
82
  const Element& Get(int index) const;
90
93
  void RemoveLast();
91
94
  void Clear();
92
95
  void MergeFrom(const RepeatedField& other);
 
96
  void CopyFrom(const RepeatedField& other);
93
97
 
94
98
  // Reserve space to expand the field to at least the given size.  If the
95
99
  // array is grown, it will always be at least doubled in size.
116
120
  // STL-like iterator support
117
121
  typedef Element* iterator;
118
122
  typedef const Element* const_iterator;
 
123
  typedef Element value_type;
119
124
 
120
125
  iterator begin();
121
126
  const_iterator begin() const;
127
132
  int SpaceUsedExcludingSelf() const;
128
133
 
129
134
 private:
130
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedField);
131
 
 
132
135
  static const int kInitialSize = 4;
133
136
 
134
137
  Element* elements_;
203
206
  void Clear();
204
207
  template <typename TypeHandler>
205
208
  void MergeFrom(const RepeatedPtrFieldBase& other);
 
209
  template <typename TypeHandler>
 
210
  void CopyFrom(const RepeatedPtrFieldBase& other);
206
211
 
207
212
  void Reserve(int new_size);
208
213
 
300
305
  static void Merge(const string& from, string* to) { *to = from; }
301
306
};
302
307
 
303
 
class StringTypeHandler : public StringTypeHandlerBase {
 
308
class LIBPROTOBUF_EXPORT StringTypeHandler : public StringTypeHandlerBase {
304
309
 public:
305
310
  static int SpaceUsed(const string& value)  {
306
311
    return sizeof(value) + StringSpaceUsedExcludingSelf(value);
316
321
class RepeatedPtrField : public internal::RepeatedPtrFieldBase {
317
322
 public:
318
323
  RepeatedPtrField();
319
 
 
 
324
  RepeatedPtrField(const RepeatedPtrField& other);
320
325
  ~RepeatedPtrField();
321
326
 
 
327
  RepeatedPtrField& operator=(const RepeatedPtrField& other);
 
328
 
322
329
  int size() const;
323
330
 
324
331
  const Element& Get(int index) const;
327
334
  void RemoveLast();  // Remove the last element in the array.
328
335
  void Clear();
329
336
  void MergeFrom(const RepeatedPtrField& other);
 
337
  void CopyFrom(const RepeatedPtrField& other);
330
338
 
331
339
  // Reserve space to expand the field to at least the given size.  This only
332
340
  // resizes the pointer array; it doesn't allocate any objects.  If the
349
357
  // STL-like iterator support
350
358
  typedef internal::RepeatedPtrIterator<Element> iterator;
351
359
  typedef internal::RepeatedPtrIterator<const Element> const_iterator;
 
360
  typedef Element value_type;
352
361
 
353
362
  iterator begin();
354
363
  const_iterator begin() const;
365
374
  // excluding sizeof(*this).
366
375
  int SpaceUsedExcludingSelf() const;
367
376
 
368
 
  // The spaced used just by the pointer array, not counting the objects pointed
369
 
  // at.  Returns zero if the array is inlined (i.e. initial_space_ is being
370
 
  // used).
371
 
  int SpaceUsedByArray() const;
372
 
 
373
377
  // Advanced memory management --------------------------------------
374
378
  // When hardcore memory management becomes necessary -- as it often
375
379
  // does here at Google -- the following methods may be useful.
410
414
  //   methods on RepeatedPtrFieldBase.
411
415
  class TypeHandler;
412
416
 
413
 
 
414
 
 private:
415
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedPtrField);
416
417
};
417
418
 
418
419
// implementation ====================================================
425
426
}
426
427
 
427
428
template <typename Element>
 
429
inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
 
430
  : elements_(initial_space_),
 
431
    current_size_(0),
 
432
    total_size_(kInitialSize) {
 
433
  CopyFrom(other);
 
434
}
 
435
 
 
436
template <typename Element>
428
437
RepeatedField<Element>::~RepeatedField() {
429
438
  if (elements_ != initial_space_) {
430
439
    delete [] elements_;
432
441
}
433
442
 
434
443
template <typename Element>
 
444
inline RepeatedField<Element>&
 
445
RepeatedField<Element>::operator=(const RepeatedField& other) {
 
446
  CopyFrom(other);
 
447
  return *this;
 
448
}
 
449
 
 
450
template <typename Element>
435
451
inline int RepeatedField<Element>::size() const {
436
452
  return current_size_;
437
453
}
502
518
}
503
519
 
504
520
template <typename Element>
 
521
inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
 
522
  Clear();
 
523
  MergeFrom(other);
 
524
}
 
525
 
 
526
template <typename Element>
505
527
inline Element* RepeatedField<Element>::mutable_data() {
506
528
  return elements_;
507
529
}
594
616
 
595
617
template <typename Element>
596
618
inline void RepeatedField<Element>::MoveArray(
597
 
    Element to[], Element from[], int size) {
598
 
  memcpy(to, from, size * sizeof(Element));
 
619
    Element to[], Element from[], int array_size) {
 
620
  memcpy(to, from, array_size * sizeof(Element));
599
621
}
600
622
 
601
623
template <typename Element>
602
624
inline void RepeatedField<Element>::CopyArray(
603
 
    Element to[], const Element from[], int size) {
604
 
  memcpy(to, from, size * sizeof(Element));
 
625
    Element to[], const Element from[], int array_size) {
 
626
  memcpy(to, from, array_size * sizeof(Element));
605
627
}
606
628
 
607
629
 
675
697
inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
676
698
  Reserve(current_size_ + other.current_size_);
677
699
  for (int i = 0; i < other.current_size_; i++) {
678
 
    TypeHandler::Merge(other.Get<TypeHandler>(i), Add<TypeHandler>());
 
700
    TypeHandler::Merge(other.template Get<TypeHandler>(i), Add<TypeHandler>());
679
701
  }
680
702
}
681
703
 
 
704
template <typename TypeHandler>
 
705
inline void RepeatedPtrFieldBase::CopyFrom(const RepeatedPtrFieldBase& other) {
 
706
  RepeatedPtrFieldBase::Clear<TypeHandler>();
 
707
  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 
708
}
 
709
 
682
710
inline int RepeatedPtrFieldBase::Capacity() const {
683
711
  return total_size_;
684
712
}
805
833
inline RepeatedPtrField<Element>::RepeatedPtrField() {}
806
834
 
807
835
template <typename Element>
 
836
inline RepeatedPtrField<Element>::RepeatedPtrField(
 
837
    const RepeatedPtrField& other) {
 
838
  CopyFrom(other);
 
839
}
 
840
 
 
841
template <typename Element>
808
842
RepeatedPtrField<Element>::~RepeatedPtrField() {
809
843
  Destroy<TypeHandler>();
810
844
}
811
845
 
812
846
template <typename Element>
 
847
inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
 
848
    const RepeatedPtrField& other) {
 
849
  CopyFrom(other);
 
850
  return *this;
 
851
}
 
852
 
 
853
template <typename Element>
813
854
inline int RepeatedPtrField<Element>::size() const {
814
855
  return RepeatedPtrFieldBase::size();
815
856
}
846
887
}
847
888
 
848
889
template <typename Element>
 
890
inline void RepeatedPtrField<Element>::CopyFrom(
 
891
    const RepeatedPtrField& other) {
 
892
  RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
 
893
}
 
894
 
 
895
template <typename Element>
849
896
inline Element** RepeatedPtrField<Element>::mutable_data() {
850
897
  return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
851
898
}
944
991
  template<typename OtherElement>
945
992
  RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
946
993
      : it_(other.it_) {
947
 
    // Force a compiler error if the other type is not convertable to ours.
 
994
    // Force a compiler error if the other type is not convertible to ours.
948
995
    if (false) {
949
996
      implicit_cast<Element*, OtherElement*>(0);
950
997
    }
1152
1199
  }
1153
1200
 
1154
1201
 private:
1155
 
  RepeatedField<T>* const field_;
 
1202
  RepeatedField<T>* field_;
1156
1203
};
1157
1204
 
1158
1205
// A back inserter for RepeatedPtrField objects.
1183
1230
  }
1184
1231
 
1185
1232
 private:
1186
 
  RepeatedPtrField<T>* const field_;
 
1233
  RepeatedPtrField<T>* field_;
1187
1234
};
1188
1235
 
1189
1236
// A back inserter for RepeatedPtrFields that inserts by transfering ownership
1212
1259
  }
1213
1260
 
1214
1261
 private:
1215
 
  RepeatedPtrField<T>* const field_;
 
1262
  RepeatedPtrField<T>* field_;
1216
1263
};
1217
1264
}  // namespace internal
1218
1265