Added namespaces

1 files changed, 144 insertions, 129 deletions

diff --git a/spider.h b/spider.h
index 8228fae..c4c4c9c 100644
--- a/spider.h
+++ b/spider.h
@@ -17,7 +17,7 @@
  * with this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
- * $Id: spider.h 87 2007-06-22 22:37:36Z tom $
+ * $Id: spider.h 95 2007-09-21 23:01:10Z tom $
  */
 
 #ifndef VDR_SPIDER_H
@@ -28,164 +28,179 @@
 #ifdef USE_TEMPLATES_FROM_STL
 
 #include <vector>
-template <class T>
-class Array : public std::vector<T>
+
+namespace Spider
 {
-public:
-  Array(int length) : std::vector<T>(length) {}
-};
-template <class T> class Vector : public std::vector<T> {};
+  //--- template class Array ---------------------------------------------------
 
-#else // use own templates
+  template <class T>
+  class Array : public std::vector<T>
+  {
+  public:
+    Array(int length) : std::vector<T>(length) {}
+  };
+
+  //--- template class Vector --------------------------------------------------
 
-/** --- template class Array ----------------------------------------------- **/
+  template <class T> class Vector : public std::vector<T> {};
 
-template <class T>
-class Array
+} // namespace Spider
+
+#else // use own templates
+
+namespace Spider
 {
-protected:
-  T* array;
-  int count;
-public:
+  //--- template class Array ---------------------------------------------------
 
-  /** Constructor */
-  Array(int length)
+  template <class T>
+  class Array
   {
-    array = new T[length];
-    count = length;
-  }
+  protected:
+    T* array;
+    int count;
+  public:
 
-  /** Destructor */
-  ~Array()
-  {
-    delete[] array;
-  }
+    /** Constructor */
+    Array(int length)
+    {
+      array = new T[length];
+      count = length;
+    }
 
-  /** Reference to an item of the array */
-  T& operator[](int p)
-  {
-    return array[p];
-  }
+    /** Destructor */
+    ~Array()
+    {
+      delete[] array;
+    }
 
-  /** Reference to an item of the array */
-  const T& operator[](int p) const
-  {
-    return array[p];
-  }
+    /** Reference to an item of the array */
+    T& operator[](int p)
+    {
+      return array[p];
+    }
 
-  /** Length of the array */
-  unsigned int size() const
-  {
-    return count;
-  }
+    /** Reference to an item of the array */
+    const T& operator[](int p) const
+    {
+      return array[p];
+    }
 
-  /** Is the array empty? */
-  bool empty() const
-  {
-    return count == 0;
-  }
-};
+    /** Length of the array */
+    unsigned int size() const
+    {
+      return count;
+    }
 
+    /** Is the array empty? */
+    bool empty() const
+    {
+      return count == 0;
+    }
+  };
 
-/** --- template class Vector ---------------------------------------------- **/
 
-template <class T>
-class Vector
-{
-protected:
-  T* vector;
-  int max;
-  int count;
-  int steps;
-
-  /** Resize the vector to the new length */
-  void resize(int m)
+  //--- template class Vector --------------------------------------------------
+
+  template <class T>
+  class Vector
   {
-    if (m < steps)
-      m = steps;
-    else
-      m = ((m - 1) / steps + 1) * steps;
-    if (m != max)
-    {
-      T* v = new T[m];
-      for (int i = 0; i < count; ++i)
-        v[i] = vector[i];
-      delete[] vector;
-      vector = v;
-      max = m;
+  protected:
+    T* vector;
+    int max;
+    int count;
+    int steps;
+
+    /** Resize the vector to the new length */
+    void resize(int m)
+    {
+      if (m < steps)
+        m = steps;
+      else
+        m = ((m - 1) / steps + 1) * steps;
+      if (m != max)
+      {
+        T* v = new T[m];
+        for (int i = 0; i < count; ++i)
+          v[i] = vector[i];
+        delete[] vector;
+        vector = v;
+        max = m;
+      }
     }
-  }
 
-public:
+  public:
 
-  /** Contructor */
-  Vector(int stepCount = 10)
-  {
-    vector = new T[stepCount];
-    max = steps = stepCount;
-    count = 0;
-  }
+    /** Contructor */
+    Vector(int stepCount = 10)
+    {
+      vector = new T[stepCount];
+      max = steps = stepCount;
+      count = 0;
+    }
 
-  /** Destructor */
-  ~Vector()
-  {
-    delete[] vector;
-  }
+    /** Destructor */
+    ~Vector()
+    {
+      delete[] vector;
+    }
 
-  /** Reference to an item of the vector */
-  T& operator[](int p)
-  {
-    return vector[p];
-  }
+    /** Reference to an item of the vector */
+    T& operator[](int p)
+    {
+      return vector[p];
+    }
 
-  /** Reference to an item of the vector */
-  const T& operator[](int p) const
-  {
-    return vector[p];
-  }
+    /** Reference to an item of the vector */
+    const T& operator[](int p) const
+    {
+      return vector[p];
+    }
 
-  /** Reference to an item of the vector */
-  T& back()
-  {
-    return vector[count - 1];
-  }
+    /** Reference to an item of the vector */
+    T& back()
+    {
+      return vector[count - 1];
+    }
 
-  /** Reference to an item of the vector */
-  const T& back() const
-  {
-    return vector[count - 1];
-  }
+    /** Reference to an item of the vector */
+    const T& back() const
+    {
+      return vector[count - 1];
+    }
 
-  /** Current length of the vector */
-  unsigned int size() const
-  {
-    return count;
-  }
+    /** Current length of the vector */
+    unsigned int size() const
+    {
+      return count;
+    }
 
-  /** Is the vector empty? */
-  bool empty() const
-  {
-    return count == 0;
-  }
+    /** Is the vector empty? */
+    bool empty() const
+    {
+      return count == 0;
+    }
 
-  /** Add an item to the end of the vector */
-  void push_back(const T& item)
-  {
-    resize(count + 1);
-    vector[count] = item;
-    ++count;
-  }
+    /** Add an item to the end of the vector */
+    void push_back(const T& item)
+    {
+      resize(count + 1);
+      vector[count] = item;
+      ++count;
+    }
 
-  /** Remove an item from the end of the vector */
-  void pop_back()
-  {
-    if (count > 0)
+    /** Remove an item from the end of the vector */
+    void pop_back()
     {
-      --count;
-      resize(count);
+      if (count > 0)
+      {
+        --count;
+        resize(count);
+      }
     }
-  }
-};
+  };
+
+} // namespace Spider
+
 #endif
 
 #endif // VDR_SPIDER_H