author Mike Hommey <>
Wed, 05 Apr 2017 13:48:52 +0900
changeset 402137 7ad4be04d16e0d86508c15c104f9686f2493061a
parent 364768 42d33a2ab63bb176c1e0f4f692d17288654d9519
child 416856 8069471cda21110700b5a451641f3e2faed95418
permissions -rw-r--r--
Bug 1344038 - Move the gio protocol handler under netwerk/protocol. r=chmanchester,karlt Historically, we had support for some GNOME VFS protocols through the gnomevfs library, and this was under extension. This may not have been built by default when it was introduced, but GNOME upstream moved those things into Gtk itself, and we then got support for the new Gio-based protocol, similar to what we had through the gnomevfs library. Time passes, and we switched off the gnomevfs library entirely, and enabled the Gio-based protocol handlers by default. We then removed everything related to the gnomevfs library. Fast forward to now, and disabling Gio support in Firefox just doesn't make sense, and leaving the gio protocol handler as an extension doesn't make sense either. As it is a protocol handler, its natural place is under netwerk/protocol, which is where we're moving it here. The netwerk/protocol subdirectories being handled automatically, we don't need to add the moved directory in any DIRS variable.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */

/* EnumeratedArray is like Array, but indexed by a typed enum. */

#ifndef mozilla_EnumeratedArray_h
#define mozilla_EnumeratedArray_h

#include "mozilla/Array.h"
#include "mozilla/Move.h"

namespace mozilla {

 * EnumeratedArray is a fixed-size array container for use when an
 * array is indexed by a specific enum class.
 * This provides type safety by guarding at compile time against accidentally
 * indexing such arrays with unrelated values. This also removes the need
 * for manual casting when using a typed enum value to index arrays.
 * Aside from the typing of indices, EnumeratedArray is similar to Array.
 * Example:
 *   enum class AnimalSpecies {
 *     Cow,
 *     Sheep,
 *     Count
 *   };
 *   EnumeratedArray<AnimalSpecies, AnimalSpecies::Count, int> headCount;
 *   headCount[AnimalSpecies::Cow] = 17;
 *   headCount[AnimalSpecies::Sheep] = 30;
template<typename IndexType,
         IndexType SizeAsEnumValue,
         typename ValueType>
class EnumeratedArray
  static const size_t kSize = size_t(SizeAsEnumValue);

  typedef Array<ValueType, kSize> ArrayType;

  ArrayType mArray;

  EnumeratedArray() {}

  template <typename... Args>
  MOZ_IMPLICIT EnumeratedArray(Args&&... aArgs)
    : mArray{mozilla::Forward<Args>(aArgs)...}

  explicit EnumeratedArray(const EnumeratedArray& aOther)
    for (size_t i = 0; i < kSize; i++) {
      mArray[i] = aOther.mArray[i];

  EnumeratedArray(EnumeratedArray&& aOther)
    for (size_t i = 0; i < kSize; i++) {
      mArray[i] = Move(aOther.mArray[i]);

  ValueType& operator[](IndexType aIndex)
    return mArray[size_t(aIndex)];

  const ValueType& operator[](IndexType aIndex) const
    return mArray[size_t(aIndex)];

  typedef typename ArrayType::iterator               iterator;
  typedef typename ArrayType::const_iterator         const_iterator;
  typedef typename ArrayType::reverse_iterator       reverse_iterator;
  typedef typename ArrayType::const_reverse_iterator const_reverse_iterator;

  // Methods for range-based for loops.
  iterator begin() { return mArray.begin(); }
  const_iterator begin() const { return mArray.begin(); }
  const_iterator cbegin() const { return mArray.cbegin(); }
  iterator end() { return mArray.end(); }
  const_iterator end() const { return mArray.end(); }
  const_iterator cend() const { return mArray.cend(); }

  // Methods for reverse iterating.
  reverse_iterator rbegin() { return mArray.rbegin(); }
  const_reverse_iterator rbegin() const { return mArray.rbegin(); }
  const_reverse_iterator crbegin() const { return mArray.crbegin(); }
  reverse_iterator rend() { return mArray.rend(); }
  const_reverse_iterator rend() const { return mArray.rend(); }
  const_reverse_iterator crend() const { return mArray.crend(); }

} // namespace mozilla

#endif // mozilla_EnumeratedArray_h