Ошибка C2679 бинарный "<<": не найден оператор, принимающий правый операнд типа

        void SerializeInstitute(ofstream& fileStream, Institute imi)
        {
            fileStream << "Course{\n" << endl << "Students: " << imi.getStudents() << endl << "Lecturers: " << imi.getLecturers() << endl << "getCourses: " << imi.getCourses() << "getMarks: " << imi.getMarks()  << endl << "}";
        }

vector<Student> Institute::getStudents()
{
        return students;
};

template<class T>
ostream& operator<<(std::ostream& os, const vector<T>& vect)
{
    for (size_t i = 0; i < vect.size(); ++i)
        os << vect[i] << "\t";
    os << "\n";
    return os;
}

ostream& operator<<(std::ostream& os, const Student& s)
{
        os << s.getStudentNo();
        os << s.getGroupName();
    os << "\n";
    return os;
}

#pragma once
#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string>
#include <vector>
#include "Person.h"
using namespace std;
using namespace per;
namespace stud
{
class Student :public Person
{private:
    string StudentNo = "123";
    string GroupName = "FIIT-21";
 
public:
    void setStudentNo(string newStudentNo);
    void setGroupName(string newGroupName);
    string getStudentNo();
    string getGroupName();
    
};
}
 
#endif

#pragma once
#ifndef _INSTITUTE_H_
#define _INSTITUTE_H_
#include <string>
#include <vector>
#include "Student.h"
#include "Lecturer.h"
#include "Course.h"
#include "Mark.h"
using namespace mar;
using namespace cours;
using namespace stud;
using namespace std;
using namespace lect;
namespace insti
{
    class Institute
    {
    private:
        vector<stud::Student>students;
        vector<lect::Lecturer>lecturers;
        vector<cours::Course>courses;
        vector<mar::Mark>marks;
 
    public:
        void AddStudent(stud::Student newStudent);
        vector<Student>GetStudentsGroup(std::string groupName);
        Student GetStudent(std::string studentNo);
        bool DeleteStudent(std::string studentNo);
        void AddEmployee(Lecturer employee);
        Lecturer GetEmployee(int personnelNo);
        bool DeleteEmployee(int personnelNo);
        void AddCourse(Course course);
        Course GetCourse(int id);
        bool DeleteCourse(int id);
        void AddMark(Mark tmpMarks);
        vector<Mark> GetCourseMarks(int courseId);
        vector<Mark> GetStudentMarks(std::string studentNo);
        vector<Mark> GetGroupMarks(std::string groupName);
        vector<Student> getStudents();
        vector<Lecturer> getLecturers();
        vector<Course> getCourses();
        vector<Mark> getMarks();
 
    };
}
 
#endif

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<fstream>
#include"Person.h"
#include "Institute.h"
#include"Lecturer.h"
#include "Student.h"
#include <string>
#include <vector>
#include"Mark.h"
#include"Course.h"
#include "Institute.h"
using namespace insti;
using namespace per;
using namespace lect;
using namespace stud;
using namespace mar;
using namespace cours;
using namespace std;
 
 
template<class T>
ostream& operator<<(std::ostream& os, const vector<T>& vect)
{
    for (size_t i = 0; i < vect.size(); ++i)
        os << vect[i];
    os << "\n";
    return os;
}
 
ostream& operator<<(std::ostream& os, const Student& s)
{
        os << s.getStudentNo();
        os << s.getGroupName();
    os << "\n";
    return os;
}
 
 
 
namespace seria
{
 
    class Serializer
    {
    public:
        void SerializePerson(std::ofstream& fileStream, Person person)
        {
            fileStream << "Person{\n" << person.get_FIO() << endl << person.get_Email() << endl;
        };
 
 
        Person DeserializePerson(std::ifstream& fileStream)
        {
            
            string s;
            getline(fileStream, s);
            Person person;
            if (s.compare("Person") == 0)
            {
                fileStream >> s; //"{"
                string n;
                fileStream >> n;  
                person.set_FIO(n);
                fileStream >> n;
                person.set_Email(n);
                return person;
            }
        };
 
 
 
 
 
 
 
 
 
        void SerializeLecturer(std::ofstream& fileStream, Lecturer lecturer)
        {
            fileStream << "Lecturer{\n" <<"fio: "<< lecturer.get_FIO() << endl<<"email: " << lecturer.get_Email() << endl<<"position: " << lecturer.getPosition() << endl<<"personnelNo: " << lecturer.getPersonnelNo() << "\n}";
        };
        Lecturer DeserializeLecturer(std::ifstream& fileStream)
        {
            string s;
            getline(fileStream, s);
            Lecturer lecturer;
            if (s.compare("Lecturer") == 0)
            {
                fileStream >> s; //"{"
                string n;
                fileStream >> n;    //превращение строки в объект (обратная операция сериализации, когда мы заносили объект в текстовый файл)
                lecturer.set_FIO(n);
                fileStream >> n;
                lecturer.set_Email(n);
                fileStream >> n;
                lecturer.setPosition(n);
                int nn;fileStream >> nn;
                lecturer.setPersonnelNo(nn);
                return lecturer;
            }
        };
    
 
 
 
 
 
 
 
 
 
 
 
        void SerializeStudent(std::ofstream& fileStream, Student student)
        {
            SerializePerson(fileStream, student);
            fileStream <<"Group: " << student.getGroupName() << endl <<"Student Number: " << student.getStudentNo() << endl << "}";
        };
 
        Student DeserializeStudent(std::ifstream& fileStream)
        {
 
            /*
            string s;
            getline(fileStream, s);
            Person person;
            if (s.compare("Person") == 0)
            {
                fileStream >> s; //"{"
                string n;
                fileStream >> n;  
                person.set_FIO(n);
                fileStream >> n;
                person.set_Email(n);
                return person;
            }*/
 
 
 
 
            string s;
            getline(fileStream, s);
            Student student;
            if (s.compare("Person") == 0)
            {
                fileStream >> s; //"{"
                string n;
                fileStream >> n;    //фио и мейл уже записаны из Person
                student.setStudentNo(n);
                fileStream >> n;
                student.setGroupName(n);
                return student;
            }
        };
 
 
 
 
 
        void SerializeMark(std::ofstream& fileStream, Mark mark)
        {
            fileStream << "Mark{\n" << "year: " << mark.getYear() << endl << "StudentNo: " << mark.getStudentNo() << endl << "Coursed: " << mark.getCourseId() << endl << "Mark: " << mark.getMark() << endl << "}";
        };
        Mark DeserializeMark(std::ifstream& fileStream)
        {
            string s;
            getline(fileStream, s);
            Mark mark;
            if (s.compare("Mark") == 0)
            {
                fileStream >> s; //"{"
                int n;
                fileStream >> n;    //превращение строки в объект (обратная операция сериализации, когда мы заносили объект в текстовый файл)
                mark.setYear(n);
                string s;
                fileStream >> s;
                mark.setStudentNo(s);
                fileStream >> n;
                mark.setCourseId(n);
                fileStream >> n;
                mark.setMark(n);
                return mark;
            }
        };
 
 
 
 
 
 
 
 
 
 
 
 
        void SerializeCourse(std::ofstream& fileStream, Course course)
        {
            Lecturer lecturer;
            fileStream << "Course{\n" << "Subject: " << course.getSubject() << endl << "Semester: " << course.getSemester() << endl << "PersonnelNo: " << lecturer.getPersonnelNo() << endl << "}";
        };
        Course DeserializeCourse(std::ifstream& fileStream)
        {
            string s;
            getline(fileStream, s);
            Course course;
            Lecturer lect;
            if (s.compare("Course") == 0)
            {
                fileStream >> s; //"{"
                int n;
                string s;
                fileStream >> s;    //превращение строки в объект (обратная операция сериализации, когда мы заносили объект в текстовый файл)
                course.setSubject(s);
                fileStream >> n;
                course.setSemester(n);
                fileStream >> n;
                lect.setPersonnelNo(n);
                return course;
            }
        };
 
 
        void SerializeInstitute(ofstream& fileStream, Institute imi)
        {
            fileStream  <<imi.getStudents() << endl << "Lecturers: " << imi.getLecturers() << endl << "getCourses: " << imi.getCourses() << "getMarks: " << imi.getMarks() << endl << "}";
 
        }
 
 
 
        Institute DeserializeInstitute(ifstream fileStream)
        {
                string s;
    getline(fileStream, s);
    Institute institute;
    if (s.compare("Institute") == 0)
    {
        
        fileStream >> s; //"{"
         Course c;
         int s;
        fileStream >> s;
        c.setSemester(s);
        institute.AddCourse(c);
 
        Lecturer l;
        string ts;
        fileStream >> ts;
        l.set_FIO(ts);
        institute.AddEmployee(l);
 
        Mark m;
        int fs;
        fileStream >> fs;
        m.setMark(fs);
        institute.AddMark(m);
 
        Student a;
        string ss;
        fileStream >> ss;
        a.set_FIO(ss);
        institute.AddStudent(a);
 
        
        return institute;
    }
};
 
        
 
 
 
 
        //Person DeserializePerson(std::ifstream& fileStream)
        //{
 
        //  string s;
        //  getline(fileStream, s);
        //  Person person;
        //  if (s.compare("Person") == 0)
        //  {
        //      fileStream >> s; //"{"
        //      string n;
        //      fileStream >> n;
        //      person.set_FIO(n);
        //      fileStream >> n;
        //      person.set_Email(n);
        //      return person;
        //  }
        //};
 
 
 
 
    };
}

template<class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vect) {
 std::copy(vect.begin(), vect.end(), std::ostream_iterator<T>(std::cout, "\t"));
 os << std::endl;
 return os;
}