Форумное образование

#include <iostream>
#include <sstream>
#include <string>
#include <list>

using namespace std;

// Компонент представления
class UserInterface
{
public:
    void SetString(const string &str){cout << str << endl;}
    string GetString(){string str; getline(cin, str, '\n'); return str;}
    // выводит набор строк (ФИО адресатов, например)
    void SetListString(const list<string> &lstStr)
    {
        for(list<string>::const_iterator p = lstStr.begin(); p != lstStr.end(); ++p)
        {
            cout << *p << endl;
        }
    }
};
// Все! Компонент Представления для консоли готов!

class Controller
{
    UserInterface view_;
    //AddressBook adrBook_;
    void FindCommand(const string &str)
    {
        view_.SetString("Searching Results: ");
        list<string> ls;
        for(size_t i = 1; i <= 5; ++i)
        {
            stringstream oss;
            oss << i << ". " << str << "...";
            ls.push_back(oss.str());
        }

        view_.SetListString(ls);
    }
    void DeleteCommand(const string &str)
    {
        view_.SetString("Address is Deleted\n");
    }
    void SetCommand(const string &str)
    {
        view_.SetString("Address is Added to Base\n");
    }
    void GetCommand(const string &str)
    {
        view_.SetString("Name: ***\nEmail: ***@***.***\nTel.: +7 *** ******\n");
    }
    int step_;
public:
    Controller():step_(0){}
    void Start(){view_.SetString("Welcome to the Adress Book!\n");}
    bool TestView(); // тут считывается и выполняется команда
};

bool Controller::TestView()
{
    string command, str;
    switch(step_)
    {
        case 0:
        {
            view_.SetString("Input the name or input q to Quit");
            string str = view_.GetString();
            if(str == "q")
                return false;
            else
            {
                FindCommand(str);
                step_ = 1;
                // вариант, когда имя не нашлось пока не анализируем
            }
            break;
        }
        case 1:
        {
            view_.SetString("Select number or input zero to add new Address");
            string str = view_.GetString();
            if(str == "0")
            {
                view_.SetString("Function is not available now");
                break;
            }
            // пока только выбор - ввод нового имени не реализован
            GetCommand(str);
            step_ = 0;
            break;
        }
        default: break;
    }
    return true;
}

int main()
{
    Controller contr;
    contr.Start();
    while (contr.TestView()){}
    return 0;
}

#include <memory>

using namespace std;

//*****************************************************
// Интерфейс компонента Менеджера Файла
/*
    Файл состоит из ячеек.
    Каждая ячейка включает
    идентификатор типа int
    и набор строк.
*/
class FileManagerMaker
{
public:
    // возвращает весь набор n-ных строк
    // и набор идентификаторов
    virtual pair< vector<int>, vector<string> > GetField(int n) = 0;
    // Возвращает содержимое ячейки с заданным идентификатором
    virtual vector<string> GetAddress(int id) = 0;
    virtual string GetString(int id, int n) = 0;
    // Устанавливает значение n-ной строки, с идентификатором id
    virtual bool SetString(int id, int n, const string &str) = 0;
    // Устанавливает адрес целиком. Возвращает true, если успешно
    virtual bool SetAddress(int id, const vector<string> &vs) = 0;
    virtual bool DeleteAddress(int id) = 0;
    // Возвращает идентификатор или 0 при ошибке
    virtual int AddAddress(const vector<string> &vs) = 0;
    // Создает объект потомка
    static FileManagerMaker* MakeFileManager();
    virtual ~FileManagerMaker(){}
};
// Главный класс компонента Менеджера Файла
class FileManager: public FileManagerMaker
{
public:
    pair< vector<int>, vector<string> > GetField(int n){}
    string GetString(int id, int n){}
    vector<string> GetAddress(int id){}
    bool SetString(int id, int n, const string &str){}
    bool SetAddress(int id, const vector<string> &vs){}
    bool DeleteAddress(int id){};
    int AddAddress(const vector<string> &vs){};
    //...
};

FileManagerMaker* FileManagerMaker::MakeFileManager()
{
    return new FileManager;
}
//*****************************************************

// Интерфейс компонента Менеджера Адреса
class AddressManagerMaker
{
public:
    virtual vector< pair<string, int> > FindName(const string &str) = 0;
    virtual bool SetAddress(int id, const vector<string> &vs) = 0;
    virtual bool AddAddress(int id, const vector<string> &vs) = 0;
    virtual vector<string> GetAddress(int id) = 0;
    virtual bool DeleteAddress(int id) = 0;
    static AddressManagerMaker* MakeAddressManager();
    virtual ~AddressManagerMaker(){}
};

class AddressManager: public AddressManagerMaker
{
    std::auto_ptr<FileManagerMaker> pMnFile_;
public:
    vector< pair<string, int> > FindName(const string &str){};
    bool SetAddress(int id, const vector<string> &vs){};
    bool AddAddress(int id, const vector<string> &vs){};
    vector<string> GetAddress(int id){};
    bool DeleteAddress(int id){};
    AddressManager():pMnFile_(FileManagerMaker::MakeFileManager()){}
};

AddressManagerMaker* AddressManagerMaker::MakeAddressManager()
{
    return new AddressManager;
}

//*****************************************************
class Controller
{
    std::auto_ptr<AddressManagerMaker> pMnAddress_;
public:
    Controller():pMnAddress_(AddressManagerMaker::MakeAddressManager()){}
};

#include <iostream>
#include <list>
#include <vector>
using namespace std;
//************************************************************
// итераторы
//************************************************************

class Iterator
{
public:
    virtual ~Iterator() {}

    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() = 0;
    virtual string CurrentItem() = 0;
};
//------------------------------------------------------------

class NullIterator: public Iterator
{
protected:
    string sData;
public:
    NullIterator(string Data)
    {
        sData = Data;
    }

    virtual void First() {}
    virtual void Next() {}

    virtual bool IsDone()
    {
        return true;
    }

    virtual string CurrentItem()
    {
        return sData;
    }
};
//------------------------------------------------------------

class ListIterator: public Iterator
{
protected:
    list<string> *pList;
    list<string>::iterator iter;
public:
    ListIterator(list<string> *ptrList)
    {
        pList = ptrList;
    }

    virtual void First()
    {
        iter = pList->begin();
    }

    virtual void Next()
    {
        iter++;
    }

    virtual bool IsDone()
    {
        return (pList->end() == iter);
    }

    virtual string CurrentItem()
    {
        return *iter;
    }
};
//************************************************************
// базовый класс для записей адреса (имя, телефон, е-мейл и т.д.)
//************************************************************

class Record
{
public:
    virtual ~Record() {}

    virtual Iterator* CreateIterator() = 0;

    virtual void Insert(string Data) = 0;
    virtual void Remove(string Data) = 0;

    virtual bool Compare(Record *pRec) = 0;
    virtual string ToString() = 0;
};
//------------------------------------------------------------
// пример простой записи адреса

class Nickname: public Record
{
private:
    string sData;
public:
    Iterator* CreateIterator()  {return new NullIterator(sData);}

    void Insert(string Data)
    {
        sData = Data;
    }

    void Remove(string Data)
    {
        if (sData == Data)  sData.clear();
    }

    bool Compare(Record *pRec)
    {
        Nickname *pNick;
        if ((pNick = dynamic_cast<Nickname*>(pRec)) == NULL)    return false;
        return (sData == pNick->sData);
    }

    string ToString()   {return sData;}
};
//------------------------------------------------------------
// пример составной записи адреса

class Telephone: public Record
{
private:
    list<string> listTelephones;
public:
    Iterator* CreateIterator()  {return new ListIterator(&listTelephones);}

    void Insert(string Data)
    {
        listTelephones.push_back(Data);
        listTelephones.unique();
    }

    void Remove(string Data)
    {
        listTelephones.erase( find(listTelephones.begin(), listTelephones.end(), Data) );
    }

    bool Compare(Record *pRec)
    {
        Telephone *pTelephone;
        if ((pTelephone = dynamic_cast<Telephone*>(pRec)) == NULL)  return false;
        return (listTelephones == pTelephone->listTelephones);
    }

    string ToString()
    {
        string sBuffer;

        for (list<string>::iterator iter = listTelephones.begin();
            iter != listTelephones.end(); iter++)
        {
            if (!sBuffer.empty())   sBuffer += "\r\n";
            sBuffer += *iter;
        }

        return sBuffer;
    }
};
//************************************************************
// производящая функция записей
//************************************************************
const unsigned MAX_RECORD_TYPES = 2;
enum RecordTypes{   NICK = 0, TEL   };

Record* MakeRecord(RecordTypes Type)
{
    switch (Type)
    {
        case NICK:  return new Nickname;
        case TEL:   return new Telephone;
    }

    return NULL;
}
//************************************************************
// собственно адрес
//************************************************************

class Address
{
private:
    int Id;
    vector<Record*> vContent;

    void CreateContent()
    {
        for (unsigned i = 0; i < MAX_RECORD_TYPES; i++) vContent.push_back( MakeRecord(RecordTypes(i)) );
    }

    void DeleteContent()
    {
        for (unsigned i = 0; i < MAX_RECORD_TYPES; i++) delete vContent;
        vContent.clear();
    }
public:
    Address()
    {
        Id = -1;
        CreateContent();
    }

    Address(int Identifier)
    {
        Id = Identifier;
        CreateContent();
    }

    Address(const Address& Ad)
    {
        Id = Ad.Id;
        CreateContent();
        for (unsigned i = 0; i < vContent.size(); i++)  *vContent = *Ad.vContent;
    }

    ~Address()
    {
        DeleteContent();
    }

    int GetId() {return Id;}
    void SetId(int newId)   {Id = newId;}

    Record* Get(RecordTypes Type)
    {
        return vContent[Type];
    }

    Record* operator[] (RecordTypes Type)
    {
        return vContent[Type];
    }

    bool Compare(Address& Ad)
    {
        bool bIdentical = true;
        for (unsigned i = 0; i < MAX_RECORD_TYPES; i++)
        {
            if ( !vContent->Compare(Ad.vContent) )
            {
                bIdentical = false;
                break;
            }
        }

        return bIdentical;
    }

    vector<string> ToVectorOfString()
    {
        vector<string> vOut;

        for (unsigned i = 0; i < MAX_RECORD_TYPES; i++)
        {
            vOut.push_back( vContent->ToString() );
        }

        return vOut;
    }
};
//************************************************************
// менеджер файла (заглушка)
//************************************************************

class FileMan
{
    typedef vector<string> AddressImage;
    vector<AddressImage> DataFile;
public:
    FileMan(string sFileName)
    {
        AddressImage AdImage;

        AdImage.push_back("Ivan Ivanov");
        AdImage.push_back("111111111");
        DataFile.push_back(AdImage);

        AdImage.clear();
        AdImage.push_back("John Doe");
        DataFile.push_back(AdImage);

        AdImage.clear();
        AdImage.push_back("John Smith");
        AdImage.push_back("2222222222");
        AdImage.push_back("33333333");
        DataFile.push_back(AdImage);
    }

    ~FileMan()
    {
        DataFile.clear();
    }

    bool Read(unsigned Identifier, unsigned LineNumber, string& sOut)
    {
        sOut = "";
        if (Identifier >= DataFile.size())  return false;
        if (LineNumber >= DataFile[Identifier].size())  return false;
        sOut = DataFile[Identifier][LineNumber];
        return true;
    }

    void Write(unsigned Identifier, unsigned LineNumber, string sLine)
    {
        AddressImage AdImage;
        while (Identifier >= DataFile.size())   DataFile.push_back(AdImage);
        while (LineNumber >= DataFile[Identifier].size())   DataFile[Identifier].push_back( string("") );

        DataFile[Identifier][LineNumber] = sLine;
    }

    void Delete(unsigned Identifier)
    {
        if (Identifier >= DataFile.size())  return;
        DataFile.erase(DataFile.begin() + Identifier);
    }

    unsigned GetCountAddresses()    {return DataFile.size();}
};
//************************************************************
// менеджер адресов
//************************************************************

class AdMan
{
    FileMan *pFile;
public:
    static const int ADDRESS_NOT_FOUND = -1;

    AdMan(string sFileName)
    {
        pFile = new FileMan(sFileName);
    }

    ~AdMan()
    {
        delete pFile;
    }

    void Add(Address *pAd)
    {
        vector<string> AdImage = pAd->ToVectorOfString();
        for (unsigned i = 0; i < AdImage.size(); i++)
        {
            pFile->Write(pAd->GetId(), i, AdImage);
        }
    }

    void Delete(int Identifier)
    {
        pFile->Delete(Identifier);
    }

    Address* Get(unsigned Identifier)
    {
        if ( Identifier >= pFile->GetCountAddresses() ) return NULL;

        Address *Ad = new Address;
        Ad->SetId(Identifier);

        string sBuffer;
        if ( pFile->Read(Identifier, 0, sBuffer) )
        {
            Ad->Get(NICK)->Insert(sBuffer);
        }

        unsigned LineNumber = 1;
        while ( pFile->Read(Identifier, LineNumber++, sBuffer) )
        {
            Ad->Get(TEL)->Insert(sBuffer);
        }

        return Ad;
    }

    int Find(Address *pAd)
    {
        for (unsigned i = 0; i < pFile->GetCountAddresses(); i++)
        {
            if (  pAd->Compare( *Get(i) )  )    return i;
        }

        return ADDRESS_NOT_FOUND;
    }

    unsigned GetCount()
    {
        return pFile->GetCountAddresses();
    }
};
//************************************************************

int main()
{
    AdMan am("test");

    // выведем все адреса из базы данных
    cout << "************* Address Base **************" << endl;

    int id = 0;
    Address *pCurAd;
    while ( (pCurAd = am.Get(id++)) != NULL )
    {
        vector<string> vOut = pCurAd->ToVectorOfString();
        for (unsigned i = 0; i < vOut.size(); i++) cout << vOut << endl;
        delete pCurAd;
        cout << endl;
    }

    // добавим новый адрес
    Address NewAd;
    NewAd.SetId( am.GetCount() );

    NewAd[NICK]->Insert("this is added address");

    NewAd[TEL]->Insert("+79110001122");
    NewAd[TEL]->Insert("01");

    am.Add(&NewAd);

    // выведем все адреса из базы данных
    cout << "********** Address Base: add address **************" << endl;

    id = 0;
    while ( (pCurAd = am.Get(id++)) != NULL )
    {
        vector<string> vOut = pCurAd->ToVectorOfString();
        for (unsigned i = 0; i < vOut.size(); i++) cout << vOut << endl;
        delete pCurAd;
        cout << endl;
    }

    // удалим адрес
    am.Delete(1);

    // выведем все адреса из базы данных
    cout << "********** Address Base: delete address 1 **************" << endl;

    id = 0;
    while ( (pCurAd = am.Get(id++)) != NULL )
    {
        vector<string> vOut = pCurAd->ToVectorOfString();
        for (unsigned i = 0; i < vOut.size(); i++) cout << vOut << endl;
        delete pCurAd;
        cout << endl;
    }

    // найдем адрес
    cout << "*********** Find address (John Smith 2222 etc) ***********" << endl;

    if (am.Find(am.Get(1)) == am.ADDRESS_NOT_FOUND) cout << "Not found" << endl;
    else    cout << "Found" << endl;

    return 0;
}