source: lliurex-apt/trunk/fuentes/src/Commands.cpp @ 923

#include "Sources.hpp"
#include "Commands.hpp"

#include <iostream>

#include <glibmm.h>
#include <giomm.h>

using namespace std;
using namespace net::lliurex::apt;
using namespace net::lliurex::apt::command;

Match::Match(Sources * sources,FindLineStatus status)
{
        this->sources=sources;
        this->status=status;
}

void net::lliurex::apt::command::Init()
{
        Glib::init();
        Gio::init();
}


vector<Sources> net::lliurex::apt::command::LoadConf()
{
        vector<Sources> conf;
        
        Glib::RefPtr<Gio::File> file = Gio::File::create_for_path(CONF_PATH);
        Glib::RefPtr<Gio::FileEnumerator> dir = file->enumerate_children("*");
        Glib::RefPtr<Gio::FileInfo> info = dir->next_file();
        
        while(info)
        {
                
                Sources src(CONF_PATH+info->get_name());
                conf.push_back(src);
                info=dir->next_file();
        }
        
        return conf;
}

void net::lliurex::apt::command::Show()
{
        Sources src(SOURCES_LIST);
        src.Print();
}

void net::lliurex::apt::command::List(vector<Sources> & conf)
{
        for(int n=0;n<conf.size();n++)
        {

                cout<<"["<<conf[n].name["C"]<<"]"<<endl;
                if(conf[n].optional)
                {
                        cout<<"* optional"<<endl;
                }

                conf[n].Print();
                cout<<endl;
        }
}

vector<Match> net::lliurex::apt::command::Check(Sources & src,vector<Sources> & conf)
{

        vector<Match> status;
        
        for(int n=0;n<conf.size();n++)
        {
                Sources & cf = conf[n];
                int f=0;
                int p=0;
                int nf=0;
                for(int m=0;m<cf.lines.size();m++)
                {
                        FindLineStatus s = src.Find(cf.lines[m]);
                        
                        switch(s)
                        {
                                case FindLineStatus::Found:
                                        f++;
                                break;
                                
                                case FindLineStatus::Partial:
                                        p++;
                                break;

                                case FindLineStatus::NotFound:
                                        nf++;
                                break;

                        }
                }
                
                if(f>0 && f==cf.lines.size())
                {
                        
                        status.push_back(Match(&conf[n],FindLineStatus::Found));
                }
                else
                {
                        if(f>0 || p>0)
                        {
                                status.push_back(Match(&conf[n],FindLineStatus::Partial));
                        }
                        else
                        {
                                status.push_back(Match(&conf[n],FindLineStatus::NotFound));
                        }
                }
        }

        
        return status;
}


Sources net::lliurex::apt::command::Set(Sources & isrc,vector<Sources> & conf,vector<string> & targets,bool reset)
{
        //there can only be one!
        Sources * mandatory=nullptr;
        vector<Sources *> optional;
        
        /*
        check if exists, test for valid combinations
        and fill target Sources
        */
        for(string target : targets)
        {
                //cout<<"* ["<<target<<"]"<<endl;

                bool found = false;
                
                for(int n=0;n<conf.size();n++)
                {
                        if(conf[n].name["C"]==target)
                        {
                                found = true;
                                
                                if(!conf[n].optional)
                                {
                                        if(mandatory==nullptr)
                                        {
                                                mandatory=&conf[n];
                                        }
                                        else
                                        {
                                                throw runtime_error("Only one not optional source should be selected");
                                        }
                                }
                                else
                                {
                                        optional.push_back(&conf[n]);
                                }
                        }       
                }
                
                if(!found)
                {
                        throw runtime_error("Target ["+target+"] not found");
                }
        }
        
        /*
         this flag wipes out sources configuration
        */
        if(reset)
        {
                Sources src;
                
                if(mandatory!=nullptr)
                        src=src+(*mandatory);
        
                for(int n=0;n<optional.size();n++)
                {
                        src=src+(*optional[n]);
                }
        
                        
        
                return src;
                
        }
        else
        {
                /*
                 this second step removes from the sources.list 
                 those lines matching at conf sources
                */
                Sources src=isrc;
                
                vector<SourceLine> refactor;
        
                for(int n=0;n<src.lines.size();n++)
                {
        
                        SourceLine * line = &src.lines[n];
                
                        int nf = 0;
                        for(int m=0;m<conf.size();m++)
                        {
                                if(conf[m].optional)continue;
                        
                                FindLineStatus status=conf[m].Find(*line);
                        
                                if(status!=FindLineStatus::NotFound)nf++;
                        }
                
                        if(nf!=0)
                        {
                                //cout<<"* removing "<<line->uri<<" "<<line->dist<<endl;
                        }
                        else
                        {
                                refactor.push_back(*line);
                        }
                
                }
        
                /*
                 rebuilding sources.list
                */
                src.lines=refactor;
                
                if(mandatory!=nullptr)
                        src=src+(*mandatory);
        
                for(int n=0;n<optional.size();n++)
                {
                        src=src+(*optional[n]);
                }
        
        
                
                return src;
        }
}



Sources net::lliurex::apt::command::Add(Sources & isrc,string line)
{
        Sources src=isrc;
        src.Add(line);
        
        return src;
}