C++:Error - redeclared as different kind of symbol

Could anybody kindly point out whatz wrong with the following as i have receive an error as:
Redeclared as different kind of symbol when using g++ to compile.

#ifndef associativematrix_h
#define associativematrix_h
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
template <typename T> class AssociativeMatrixData;

template <typename T>
class AssociativeMatrixIterator
{
         public:
            typedef T* pointer;
            typedef T& reference;

            AssociativeMatrixIterator& operator ++() { ++*this; return *this; }

            AssociativeMatrixIterator& operator --() { --*this; return *this; }

            AssociativeMatrixIterator operator ++(int)
            {
                  AssociativeMatrixIterator temp(*this);
                  ++*this;
                  return temp;
            }

            AssociativeMatrixIterator operator --(int)
            {
                  AssociativeMatrixIterator temp(*this);
                  --*this;
                  return temp;
            }

            AssociativeMatrixIterator operator =(const AssociativeMatrixIterator& rhs )
            {
                  this = rhs;
                  return this;
            }

            reference operator*()
            {
                  return *operator->();
            }

            pointer operator ->()
            {
                  return &this.begin();
            }

            bool operator ==(AssociativeMatrixIterator& s)
            {
                        return this == s;
            }

            bool operator !=(AssociativeMatrixIterator& rhs)
            {
                        return !( this == rhs );
            }

};

template <typename T>
class Row
{
      public:

            Row();

            Row(const Row& s); // copy constructor

            T& operator[]( const string& s );

            T operator[]( const string& s ) const;

            Row<T>& operator=( const Row<T>& s );

      private:

            vector<string> R_vStr;
            vector<T> R_vData;            
};

template <typename T>
class AssociativeMatrix
{
      public:
            AssociativeMatrixData<T>* Data;

            AssociativeMatrix();

            AssociativeMatrix( const AssociativeMatrix& s); // copy constructor

            //~AssociativeMatrix();            

            Row<T>& operator[]( const string& s );

            Row<T> operator[]( const string& s ) const;

            AssociativeMatrix<T>& operator =( const AssociativeMatrix<T>& s );

            size_t getRefCount() const;

            typedef AssociativeMatrixIterator<T> iterator;

            iterator begin() { return vData.begin(); }

            iterator end() { return vData.end(); }

            iterator& operator++();

      private:
};

template <typename T>
class AssociativeMatrixData
{
      public:
            friend class AssociativeMatrix;
            int refCount;
            vector<string> vStr;
            vector<Row<T> > vData;            
      private:
            void increment();
            void decrement();      
};
#include "AssociativeMatrix.tem"
#endif

//AssociativeMatrix.tem

#include "associativematrix.h"
#include<iostream>
#include<string>
#include<vector>

using namespace std;

template<typename T>
Row<T>::Row() { }

template<typename T>
Row<T>::Row( const Row& s )
{
      R_vStr = s.R_vStr;
      R_vData = s.R_vData;
}

template<typename T>
T& Row<T>::operator[]( const string& str )
{
      vector<string>::iterator it;

      for (it = R_vStr.begin(); it != R_vStr.end(); it++)
      {      
            if (*it == str)
            return R_vData[it - R_vStr.begin()];
      }

      R_vStr.push_back(str);
      R_vData.push_back(0);

      //cout << "Row Size : " << R_vData.size() << endl;

      return *(R_vData.end() - 1);
}

template<typename T>
T Row<T>::operator[]( const string& str ) const
{
      vector<string>::iterator it;

      for (it = R_vStr.begin(); it != R_vStr.end(); it++)
      {
            if (*it == str)
            return R_vData[it - R_vStr.begin()];
      }

      R_vStr.push_back(str);
      R_vData.push_back(0);
      return *(R_vData.end() - 1);
}

template <typename T>
Row<T>& Row<T>::operator=( const Row<T>& s )
{
      R_vStr = s.R_vStr;
      R_vData = s.R_vData;

      return *this;
}

template<typename T>
AssociativeMatrix<T>::AssociativeMatrix()
{
      Data = new AssociativeMatrixData<T>();
      Data -> refCount = 1;
}

template<typename T>
AssociativeMatrix<T>::AssociativeMatrix( const AssociativeMatrix& s )
{
      Data = s->Data;
      Data->increment();
}

template<typename T>
Row<T>& AssociativeMatrix<T>::operator[]( const string& str )
{
      vector<string>::iterator it;

      for (it = Data->vStr.begin(); it != Data->vStr.end(); it++)
      {
            if (*it == str)
            return (Data->vData[it - Data->vStr.begin()]);
      }

      Row<T> row;
      Data->vStr.push_back(str);
      Data->vData.push_back(row);
      return *(Data->vData.end()-1);
}

template<typename T>
Row<T> AssociativeMatrix<T>::operator[]( const string& str ) const
{
      vector<string>::iterator it;

      for (it = Data->vStr.begin(); it != Data->vStr.end(); it++)
      {
            if (*it == str)
            return (Data->vData[it - Data->vStr.begin()]);
      }

      incrementCount();      // increase refCount;
      Row<T> row;
      Data->vStr.push_back(str);
      Data->vData.push_back(row);
      return *(Data->vData.end()-1);
}

template <typename T>
AssociativeMatrix<T>& AssociativeMatrix<T>::operator =( const AssociativeMatrix<T>& s )
{
      Data->decrement();
      Data = s->Data;
      Data->increment();

      return *this;
}

template <typename T>
size_t AssociativeMatrix<T>::getRefCount() const
{
      return Data->refCount;
}

template <typename T>
void AssociativeMatrixData<T>::increment()
{
      refCount++;
}

template <typename T>
void AssociativeMatrixData<T>::decrement()
{
      refCount--;
      if(refCount == 0) delete this;
}