Renamed member class to hashmember, because we're going to use the member class for specifying class information

5 files changed, 32 insertions, 32 deletions

diff --git a/include/member.h b/include/hashmember.h
index 5166535..2724836 100644
--- a/include/member.h
+++ b/include/hashmember.h
@@ -1,5 +1,5 @@
 /**
- *  Member.h
+ *  HashMember.h
  *
  *  When you're accessing members in an array or an object, you're
  *  doing this via an internal member object. This is an object that
@@ -27,20 +27,20 @@ class Value;
  *  Member class
  */
 template <typename Type>
-class Member
+class HashMember
 {
 public:
     /**
      *  Destructor
      */
-    virtual ~Member() {}
+    virtual ~HashMember() {}
 
     /**
      *  Assign a value object to the array
      *  @param  value
      *  @return Member
      */
-    Member &operator=(const Value &value)
+    HashMember &operator=(const Value &value)
     {
         // set property in parent array
         _base.set(_index, value);
@@ -119,9 +119,9 @@ public:
      *  Array access operator
      *  This can be used for accessing arrays
      *  @param  index
-     *  @return Member
+     *  @return HashMember
      */
-    Member operator[](int index)
+    HashMember operator[](int index)
     {
         return _base.get(_index)[index].add(this);
     }
@@ -130,9 +130,9 @@ public:
      *  Array access operator
      *  This can be used for accessing associative arrays
      *  @param  key
-     *  @return Member
+     *  @return HashMember
      */
-    Member operator[](const std::string &key)
+    HashMember operator[](const std::string &key)
     {
         return _base.get(_index)[key].add(this);
     }
@@ -141,9 +141,9 @@ public:
      *  Array access operator
      *  This can be used for accessing associative arrays
      *  @param  key
-     *  @return Member
+     *  @return HashMember
      */
-    Member operator[](const char *key)
+    HashMember operator[](const char *key)
     {
         return _base.get(_index)[key].add(this);
     }
@@ -154,20 +154,20 @@ private:
      *  @param  base    Base value
      *  @param  index   Index in the array
      */
-    Member(const Value *base, Type index) : _base(*base), _index(index) {}
+    HashMember(const Value *base, Type index) : _base(*base), _index(index) {}
     
     /**
      *  Protected copy constructor
      *  @param  value   Other element
      */
-    Member(const Member<Type> &member) : _base(member._base), _index(member._index), _parent(member._parent) {}
+    HashMember(const HashMember<Type> &member) : _base(member._base), _index(member._index), _parent(member._parent) {}
     
     /**
      *  Add parent
      *  @param  parent
-     *  @return Member
+     *  @return HashMember
      */
-    Member &add(Member *parent)
+    HashMember &add(HashMember *parent)
     {
         _parent = parent;
         return *this;
@@ -187,9 +187,9 @@ private:
     
     /**
      *  Parent member (in case of nested members)
-     *  @var Member
+     *  @var HashMember
      */
-    Member *_parent = nullptr;
+    HashMember *_parent = nullptr;
     
     /**
      *  Only value objects may construct members
diff --git a/include/value.h b/include/value.h
index f47304a..652b7ef 100644
--- a/include/value.h
+++ b/include/value.h
@@ -31,7 +31,7 @@ namespace Php {
 /**
  *  Forward definitions
  */
-template <class Type> class Member;
+template <class Type> class HashMember;
 
 /**
  *  Class definition
@@ -467,7 +467,7 @@ public:
      *  @param  index
      *  @return Member
      */
-    Member<int> operator[](int index);
+    HashMember<int> operator[](int index);
     
     /**
      *  Array access operator
@@ -475,15 +475,15 @@ public:
      *  @param  key
      *  @return Member
      */
-    Member<std::string> operator[](const std::string &key);
+    HashMember<std::string> operator[](const std::string &key);
 
     /**
      *  Array access operator
      *  This can be used for accessing associative arrays
      *  @param  key
-     *  @return Member
+     *  @return HashMember
      */
-    Member<std::string> operator[](const char *key);
+    HashMember<std::string> operator[](const char *key);
 
 
 protected:
diff --git a/phpcpp.h b/phpcpp.h
index 724e88d..1179467 100644
--- a/phpcpp.h
+++ b/phpcpp.h
@@ -29,7 +29,7 @@
 #include <phpcpp/byval.h>
 #include <phpcpp/byref.h>
 #include <phpcpp/global.h>
-#include <phpcpp/member.h>
+#include <phpcpp/hashmember.h>
 #include <phpcpp/parameters.h>
 #include <phpcpp/function.h>
 #include <phpcpp/base.h>
diff --git a/src/includes.h b/src/includes.h
index 20e7e95..5602e06 100644
--- a/src/includes.h
+++ b/src/includes.h
@@ -42,7 +42,7 @@
 #include "../include/byval.h"
 #include "../include/byref.h"
 #include "../include/global.h"
-#include "../include/member.h"
+#include "../include/hashmember.h"
 #include "../include/parameters.h"
 #include "../include/function.h"
 #include "../include/base.h"
diff --git a/src/value.cpp b/src/value.cpp
index 2a571ab..0f6951b 100644
--- a/src/value.cpp
+++ b/src/value.cpp
@@ -778,33 +778,33 @@ const Value &Value::set(const char *key, int size, const Value &value)
  *  Array access operator
  *  This can be used for accessing arrays
  *  @param  index
- *  @return Member
+ *  @return HashMember
  */
-Member<int> Value::operator[](int index) 
+HashMember<int> Value::operator[](int index) 
 {
-    return Member<int>(this, index);
+    return HashMember<int>(this, index);
 }
 
 /**
  *  Array access operato
  *  This can be used for accessing associative arrays
  *  @param  key
- *  @return Member
+ *  @return HashMember
  */
-Member<std::string> Value::operator[](const std::string &key) 
+HashMember<std::string> Value::operator[](const std::string &key) 
 {
-    return Member<std::string>(this, key);
+    return HashMember<std::string>(this, key);
 }
 
 /**
  *  Array access operator
  *  This can be used for accessing associative arrays
  *  @param  key
- *  @return Member
+ *  @return HashMember
  */
-Member<std::string> Value::operator[](const char *key) 
+HashMember<std::string> Value::operator[](const char *key) 
 {
-    return Member<std::string>(this, key);
+    return HashMember<std::string>(this, key);
 }
 
 /**