The GroupIndex Template Library

---

IndexCommandLine.h

#ifndef DEF_INDEXCOMMANDLINE
#define DEF_INDEXCOMMANDLINE

#include <iostream>
#include <io.h>

namespace groupindex
{

template <class CIndex, class CInterface>
class IndexCommandLine
{

protected:

    typename CIndex::IndexRepresentation dr;

        // Geändert für MultiDimGList: idxHeapStream (r.b. 5.2.2002)
    std::fstream idxstream;
        std::fstream idxHeapStream;

    CIndex* groupindex;

    char indexfilename[1024];
    char* indexdirname;
    char* indexfname;

        // Für MultiDimGList:
        char* heapfname;

    int mismatches;

public:

    int command(int argc, char** args);

    IndexCommandLine();

    int run();

};

template<class CIndex, class CInterface>
int IndexCommandLine<CIndex, CInterface>::command(int argc, char** args)
{

        if (!stricmp(args[1],"CLOSE"))
        {

        if (groupindex!=NULL)
            delete groupindex;
        return 0;

    } else if (!stricmp(args[1],"OPEN")) {

        if (argc<3)
        {
                        std::cout<<"Specify index file (OPEN <indexfile>)\n";
                        return 0;
        }
    
        if (groupindex!=NULL)
            delete groupindex;

        strcpy(indexfilename,args[2]);

        if (strstr(indexfilename,"\\")==NULL && strstr(indexfilename,"/")==NULL)
        {
            indexfname = &indexfilename[0];
            indexdirname = &indexfilename[strlen(indexfilename)];
        } else {
            // letzte pos. von "\\" oder "/" in indexfilename ermitteln
            int pos = strlen(indexfilename)-1;
            char c;
            while ((c = indexfilename[pos])!='\\' && c!='/')
                pos--;
            indexfilename[pos] = 0;
            indexdirname = indexfilename;
            indexfname = &indexfilename[pos];
            chdir(indexdirname);
        }

        if (idxstream.is_open())
            idxstream.close();

#ifdef DEF_MULTIDIMGLIST
                if (idxHeapStream.is_open())
                        idxHeapStream.close();
#endif // DEF_MULTIDIMGLIST

                // geändert für Test mit MultiDimGList (r.b. 31.01.2002)
                _finddata_t fileinfo;

//        idxstream.open(indexfname,std::ios::binary);          
                if (_findfirst(indexfname, &fileinfo)==-1)
                        idxstream.open(indexfname,std::ios::binary|std::ios_base::in|std::ios_base::out|std::ios_base::trunc);
                else
                        idxstream.open(indexfname,std::ios::binary|std::ios_base::in|std::ios_base::out);

#ifdef DEF_MULTIDIMGLIST
                if (strchr(indexfname, '.')!=NULL)
                        strncpy(heapfname, indexfname, strcspn(indexfname, "."));
                else
                        strcpy(heapfname, indexfname);

                strcat(heapfname, ".hpf");

                if (_findfirst(heapfname, &fileinfo)==-1)
                        idxHeapStream.open(heapfname,std::ios::binary|std::ios_base::in|std::ios_base::out|std::ios_base::trunc);               
                else
                        idxHeapStream.open(heapfname,std::ios::binary|std::ios_base::in|std::ios_base::out);            

                dr.setHeapStream(idxHeapStream);
#endif // DEF_MULTIDIMGLIST

                if (!idxstream)
                {
            groupindex = new CIndex(dr);                
                        return 0;
        } else {
            groupindex = new CIndex(dr,idxstream);              
            return 0;
        }

    
    } else if (!stricmp(args[1],"MISMATCHES")) {

                if (argc<3)
                {
                        std::cout<<"Missing parameters (MISMATCHES <n>)\n";
                        return 0;
                }
      mismatches = atoi(args[2]);
                std::cout<<"Mismatches set to "<<mismatches<<".\n";

        return 0;

    } else if (!stricmp(args[1],"SEARCH")) {
                
        if (groupindex==NULL)
                {
                        std::cout<<"Use 'OPEN <indexfile>' to open index.\n";
                        return 0;
                }

                // Anfrage bearbeiten
                if (argc<3)
                {
                        std::cout<<"Missing parameters (SEARCH <query>)\n";
                        return 0;
                }
                                
        typename std::set<ANSI_TYPENAME CIndex::IndexSet> query;
        CInterface::parseQuery(args[2], query);         
                
                typename std::set<ANSI_TYPENAME CIndex::IndexSet>::iterator m = query.begin();

                typename CIndex::IndexSet* query_array;
        query_array = new typename CIndex::IndexSet[query.size()]; 


                int count = 0;

                while (m != query.end()) {
                  
                        query_array[count] = *m;
                        ++m; // iterator hochsetzen
                        count++; // und weiterzählen

                } 

                std::cout<<"searching pattern...\n"; std::cout.flush();
                long  hits = 0;
        ListTupel<ANSI_TYPENAME CIndex::IndexGroup >* results;
    
        idxstream.seekg(0,std::ios::beg);
        try {
                    hits = groupindex->search(query_array, query.size(), results, mismatches);
        } catch (IndexingException e) {
            std::cout<<e.what()<<std::endl;
        }
                //... anfrage-treffer ausgeben ...
                if (hits>0)
                        std::cout<<"pattern found ..."<<std::endl;
                else
                        std::cout<<"no match found ..."<<std::endl;
                std::cout.flush();

                for (int l=0; l<hits; l++)
                {
            try {
                            std::cout<<groupindex->getFileName(results[l].i).c_str()<<", "<<results[l].g<<", "<<results[l].credit<<std::endl;
                std::cout.flush();
            }
            catch(IndexingException e) {
                std::cout<<e.what()<<std::endl;
            }
                }

                if (hits>0)
                delete[] results;
                delete[] query_array;
    
        return 0;

        } else  if (!stricmp(args[1],"ADD")) {

        if (groupindex== NULL)
                {
                        std::cout<<"Use 'OPEN <indexfile>' to open index.\n";
                        return 0;
                }

                // Index erstellen
                if (argc<3)
                {
                        std::cout<<"specify paramters (ADD <datafile1> .... <datafileN>)\n";
                        return 0;
                }               

                // Namen der Daten-Files auslesen und dem Index hinzufügen
                for (int i=2; i<argc; i++)
                        CInterface::readDataFile(args[i], groupindex);

                //... und Index speichern
                std::ofstream ofs;
        char* tempfile;
        putenv("TMP=");
    
        tempfile = tempnam(".\\",indexfname);

        ofs.open(tempfile, std::ios::binary);
                ofs<<*groupindex;
        ofs.close();
        idxstream.close();

        remove(indexfname);
        rename(&tempfile[2],indexfname);

        // Index wieder zum Lesen öffnen
        std::/*i*/fstream new_idxstream;
//        new_idxstream.open(indexfname,std::ios::binary);              
                new_idxstream.open(indexfname,std::ios::binary|std::ios_base::in|std::ios_base::out);
                if (!new_idxstream)
                {
                        std::cout<<"Index File not found.\n";
                        return 0;
                }

            new_idxstream.close();
        idxstream.open(indexfname);
        groupindex = new CIndex(dr,idxstream);          

        std::cout<<"Files added and index saved in "<<indexfname<<".\n";
                
        return 0;

    } else      if (!stricmp(args[1],"REMOVE")) {

        if (groupindex==NULL)
                {
                        std::cout<<"Use 'OPEN <indexfile>' to open index.\n";
                        return 0;
                }

                if (argc<3)
                {
                        std::cout<<"Specify parameters (REMOVE <datafile1> .... <datafileN>)\n";
                        return 0;
                }               

                for (int i=2; i<argc; i++)
                groupindex->remove(args[i]);

                //... und Index speichern
                std::ofstream ofs;
        char* tempfile;
        putenv("TMP=");
    
        tempfile = tempnam(".\\",indexfname);

        ofs.open(tempfile, std::ios::binary);
                ofs<<*groupindex;
        ofs.close();
        idxstream.close();

        remove(indexfname);
        rename(&tempfile[2],indexfname);

        // Index wieder zum Lesen öffnen
        idxstream.open(indexfname,std::ios::binary);            

                if (!idxstream)
                {
                        std::cout<<"Index File not found.\n";
                        return 0;
        }

        groupindex = new CIndex(dr,idxstream);          

        std::cout<<"Files removed and index saved in "<<indexfname<<".\n";
                
        return 0;

    } else      if (!stricmp(args[1],"MERGE")) {

        if (groupindex==NULL)
                {
                        std::cout<<"Use 'OPEN <indexfile>' to open index.\n";
                        return 0;
                }

                if (argc<3)
                {
                        std::cout<<"Syntax: MERGE <indexfile2> \n";
                        return 0;
                }               
                
                groupindex->merge(args[2],MODE_MERGE_MAKE_UNIQUE);


                //... und Index speichern
                std::ofstream ofs;
        char* tempfile;
        putenv("TMP=");
    
        tempfile = tempnam(".\\",indexfname);

        ofs.open(tempfile, std::ios::binary);
                ofs<<*groupindex;
        ofs.close();
        idxstream.close();

        remove(indexfname);
        rename(&tempfile[2],indexfname);

        // Index wieder zum Lesen öffnen
        idxstream.open(indexfname,std::ios::binary);            
                if (!idxstream)
                {
                        std::cout<<"Index File not found.\n";
                        return 0;
        }

        groupindex = new CIndex(dr,idxstream);          

                std::cout<<"Index merged with Index "<<args[2]<<".\n";

        return 0;

    } else      if (!stricmp(args[1],"LIST")) {

        if (groupindex==NULL)
                {
                        std::cout<<"Use 'OPEN <indexfile>' to open index.\n";
                        return 0;
                }

        std::set<std::string> names;
        groupindex->getFilenames(names);

        std::set<std::string>::iterator it;
        for (it = names.begin(); it != names.end(); it++)
        {
            std::cout<<(*it).c_str()<<std::endl;
        }
        std::cout<<std::endl;

                } else  if (!stricmp(args[1],"OPERATE")) {
                        // Syntax: OPERATE WITH <groupfile> ON <datafile>
                        if (stricmp(args[2],"WITH") || stricmp(args[4],"ON") || stricmp(args[6],"TO")) 
                        {
                std::cout<<"Syntax: OPERATE WITH <groupfile> ON <datafile> TO <targetfile>"<<std::endl;
                                return 0;
                        }
                        
                        typename CIndex::IndexGroup g;
                        try {
                                CInterface::readGroupFile(g,args[3]);
                        } catch (IndexingException e) {
                                std::cout<<e.what()<<std::endl;
                                return 0;
                        }

                        std::cout<<g<<std::endl;
                        std::cout.flush();

         typename std::set<ANSI_TYPENAME CIndex::IndexSet> objs;

         CInterface::parseQuery(args[5],objs);

         std::ofstream outstream;
         outstream.open(args[7]);
                        
         typename std::set<ANSI_TYPENAME CIndex::IndexSet>::iterator it = objs.begin();

         for (; it!=objs.end(); ++it)
                        {
                                typename CIndex::IndexSet s = (*it);
                                g *= s;
                                std::ostream o_outstream(outstream.rdbuf());
                                o_outstream<<s;
                        }

                        outstream.close();


    } else      if (!stricmp(args[1],"EXIT")) {

        if (groupindex!=NULL)
            delete groupindex;

        return -1;

        } else {

                std::cout<<"Specify parameters:"<<std::endl<<"SEARCH <query> IN <indexfile>"<<std::endl;
                std::cout<<"ADD <datafile1> ... <datafileN>\n";
                std::cout<<"REMOVE <datafile1> ... <datafileN>\n";
                std::cout<<"MERGE <indexfile2>\n";
                std::cout<<"EXIT\n";
                std::cout<<"LIST\n";
                std::cout<<"OPEN <indexfile>\n";
                std::cout<<"CLOSE\n";
                return 0;

        }


        std::cout.flush();

        return 0;

};

template<class CIndex, class CInterface>
IndexCommandLine<CIndex, CInterface>::IndexCommandLine()
{

    groupindex = NULL;
    mismatches = 0;

        dr.setHeapStream(idxHeapStream);
}


template<class CIndex, class CInterface>
int IndexCommandLine<CIndex, CInterface>::run()
{

    bool end = false;

        char** line_input = new char*[32];
        for (int k=0; k<32;k++)
                line_input[k] = new char[128];
        strcpy(line_input[0],"IndexCommandLine");

        while (!end)
        {
                std::cout<<"> ";

                int line_count = 1;
                bool line_end = false;
                std::cout.flush();

                int len = 0;
                while (line_count<32 && !line_end)
                {
                        std::cin>>line_input[line_count];
                        len = strlen(line_input[line_count]);
            // Argument in Anführungszeichen?
            int my_len;
            char buf[128];
            if (line_input[line_count][0]=='\"')
            {
                strcpy(line_input[line_count],&line_input[line_count][1]);
                do {
                                std::cin>>buf;
                    strcat(line_input[line_count]," ");
                    strcat(line_input[line_count],buf);
                    my_len = strlen(buf);
                    len = strlen(line_input[line_count]);
                }
                while ( !(buf[my_len-1]=='\"' || (buf[my_len-2]=='\"' && buf[my_len-1]==';') ) );
                if (buf[my_len-1]=='\"')
                    line_input[line_count][len-1] = 0;
                else if (buf[my_len-2]=='\"')
                    line_input[line_count][len-2] = 0;
            }
                        if (len==0 || line_input[line_count][len-1]==';')
                                line_end = true;
                        
                        line_count++;

                }

                // semicolon entfernen
                if (len==1)
                        line_count--;
                else
                {
                        int pos = len-1;
                        while (pos>0 && line_input[line_count-1][pos]!=';')
                                pos--;
                        line_input[line_count-1][pos] = 0;
                }

                //for (int i=0; i<line_count; i++)
                //      cout<<line_input[i]<<"~";
                //cout<<endl;
                //cout.flush();

                int result;
                if (line_count>0)
            try {
                               result = command(line_count, &(line_input[0]));
                std::cout<<std::endl;
                std::cout.flush();
            } catch (IndexingException e) {
                std::cout<<e.what()<<std::endl;
            }


                if (result<0)
                        return 0;

        }

    return 0;

}

}

#endif

The GroupIndex-Template-Library
Universität Bonn, Institut für Informatik III, 2001