The Tor Browser: media/omx-plugin/include/gb/utils/VectorImpl.h@b8a032363ba2 (annotated)

media/omx-plugin/include/gb/utils/VectorImpl.h@b8a032363ba2 (annotated)

media/omx-plugin/include/gb/utils/VectorImpl.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
  * Copyright (C) 2005 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #ifndef ANDROID_VECTOR_IMPL_H
 #define ANDROID_VECTOR_IMPL_H
 #include <assert.h>
 #include <stdint.h>
 #include <sys/types.h>
 #include <utils/Errors.h>
 // ---------------------------------------------------------------------------
 // No user serviceable parts in here...
 // ---------------------------------------------------------------------------
 namespace android {
 /*!
  * Implementation of the guts of the vector<> class
  * this ensures backward binary compatibility and
  * reduces code size.
  * For performance reasons, we expose mStorage and mCount
  * so these fields are set in stone.
  *
  */
 class VectorImpl
 {
 public:
     enum { // flags passed to the ctor
         HAS_TRIVIAL_CTOR    = 0x00000001,
         HAS_TRIVIAL_DTOR    = 0x00000002,
         HAS_TRIVIAL_COPY    = 0x00000004,
     };
                             VectorImpl(size_t itemSize, uint32_t flags);
                             VectorImpl(const VectorImpl& rhs);
     virtual                 ~VectorImpl();
     /*! must be called from subclasses destructor */
             void            finish_vector();
             VectorImpl&     operator = (const VectorImpl& rhs);
     /*! C-style array access */
     inline  const void*     arrayImpl() const       { return mStorage; }
             void*           editArrayImpl();
     /*! vector stats */
     inline  size_t          size() const        { return mCount; }
     inline  bool            isEmpty() const     { return mCount == 0; }
             size_t          capacity() const;
             ssize_t         setCapacity(size_t size);
             /*! append/insert another vector or array */
             ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
             ssize_t         appendVector(const VectorImpl& vector);
             ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
             ssize_t         appendArray(const void* array, size_t length);
             /*! add/insert/replace items */
             ssize_t         insertAt(size_t where, size_t numItems = 1);
             ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
             void            pop();
             void            push();
             void            push(const void* item);
             ssize_t         add();
             ssize_t         add(const void* item);
             ssize_t         replaceAt(size_t index);
             ssize_t         replaceAt(const void* item, size_t index);
             /*! remove items */
             ssize_t         removeItemsAt(size_t index, size_t count = 1);
             void            clear();
             const void*     itemLocation(size_t index) const;
             void*           editItemLocation(size_t index);
             typedef int (*compar_t)(const void* lhs, const void* rhs);
             typedef int (*compar_r_t)(const void* lhs, const void* rhs, void* state);
             status_t        sort(compar_t cmp);
             status_t        sort(compar_r_t cmp, void* state);
 protected:
             size_t          itemSize() const;
             void            release_storage();
     virtual void            do_construct(void* storage, size_t num) const = 0;
     virtual void            do_destroy(void* storage, size_t num) const = 0;
     virtual void            do_copy(void* dest, const void* from, size_t num) const = 0;
     virtual void            do_splat(void* dest, const void* item, size_t num) const = 0;
     virtual void            do_move_forward(void* dest, const void* from, size_t num) const = 0;
     virtual void            do_move_backward(void* dest, const void* from, size_t num) const = 0;
     // take care of FBC...
     virtual void            reservedVectorImpl1();
     virtual void            reservedVectorImpl2();
     virtual void            reservedVectorImpl3();
     virtual void            reservedVectorImpl4();
     virtual void            reservedVectorImpl5();
     virtual void            reservedVectorImpl6();
     virtual void            reservedVectorImpl7();
     virtual void            reservedVectorImpl8();
 private:
         void* _grow(size_t where, size_t amount);
         void  _shrink(size_t where, size_t amount);
         inline void _do_construct(void* storage, size_t num) const;
         inline void _do_destroy(void* storage, size_t num) const;
         inline void _do_copy(void* dest, const void* from, size_t num) const;
         inline void _do_splat(void* dest, const void* item, size_t num) const;
         inline void _do_move_forward(void* dest, const void* from, size_t num) const;
         inline void _do_move_backward(void* dest, const void* from, size_t num) const;
             // These 2 fields are exposed in the inlines below,
             // so they're set in stone.
             void *      mStorage;   // base address of the vector
             size_t      mCount;     // number of items
     const   uint32_t    mFlags;
     const   size_t      mItemSize;
 };
 class SortedVectorImpl : public VectorImpl
 {
 public:
                             SortedVectorImpl(size_t itemSize, uint32_t flags);
                             SortedVectorImpl(const VectorImpl& rhs);
     virtual                 ~SortedVectorImpl();
     SortedVectorImpl&     operator = (const SortedVectorImpl& rhs);
     //! finds the index of an item
             ssize_t         indexOf(const void* item) const;
     //! finds where this item should be inserted
             size_t          orderOf(const void* item) const;
     //! add an item in the right place (or replaces it if there is one)
             ssize_t         add(const void* item);
     //! merges a vector into this one
             ssize_t         merge(const VectorImpl& vector);
             ssize_t         merge(const SortedVectorImpl& vector);
     //! removes an item
             ssize_t         remove(const void* item);
 protected:
     virtual int             do_compare(const void* lhs, const void* rhs) const = 0;
     // take care of FBC...
     virtual void            reservedSortedVectorImpl1();
     virtual void            reservedSortedVectorImpl2();
     virtual void            reservedSortedVectorImpl3();
     virtual void            reservedSortedVectorImpl4();
     virtual void            reservedSortedVectorImpl5();
     virtual void            reservedSortedVectorImpl6();
     virtual void            reservedSortedVectorImpl7();
     virtual void            reservedSortedVectorImpl8();
 private:
             ssize_t         _indexOrderOf(const void* item, size_t* order = 0) const;
             // these are made private, because they can't be used on a SortedVector
             // (they don't have an implementation either)
             ssize_t         add();
             void            pop();
             void            push();
             void            push(const void* item);
             ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
             ssize_t         appendVector(const VectorImpl& vector);
             ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
             ssize_t         appendArray(const void* array, size_t length);
             ssize_t         insertAt(size_t where, size_t numItems = 1);
             ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
             ssize_t         replaceAt(size_t index);
             ssize_t         replaceAt(const void* item, size_t index);
 };
 }; // namespace android
 // ---------------------------------------------------------------------------
 #endif // ANDROID_VECTOR_IMPL_H

The Tor Browser / annotate

media/omx-plugin/include/gb/utils/VectorImpl.h@b8a032363ba2 (annotated)

media/omx-plugin/include/gb/utils/VectorImpl.h