Zsl.hh

Go to the documentation of this file.

/*
 * Zsl.hh
 *
 *  Created on: 26 août 2008
 *      Author: ypencole
 */

#ifndef __DIADES__PETRI__ZSL__HH__
#define __DIADES__PETRI__ZSL__HH__




#include <sstream>
#include <vector>
#include <diades/utils/Assertion.hh>
#include <diades/petri/Net.hh>

namespace Diades
{
namespace Petri
{

class ZslInvalid : public runtime_error, public domain_error {
public:
  ZslInvalid(const string& whatArg) : runtime_error(whatArg),  domain_error(whatArg){
    cerr << "EXCEPTION Zsl -> " << whatArg << endl;
  }
};

class ZslFactory;

class Zsl
{
private:
        int _value;
        unsigned _id;
        Place _place;
        const Zsl * _next;

public:
        Zsl():_value(0),_id(0),_place(),_next(0){}

private:
        Zsl(Place p, int value, const Zsl * zsl, unsigned id ):_value(value), _id(id), _place(p), _next(zsl) {
                require(ZslInvalid,p.valid(),"Zsl: invalid place");
                require(ZslInvalid,id > 0, "Zsl: null id");
                require(ZslInvalid,value != 0, "Zsl: null value");
                require(ZslInvalid,(zsl == 0) || (zsl->valid()), "invalid next");
        }



public:

        virtual ~Zsl(){}

        unsigned id() const { return _id; }

        int value() const { return _value; }

        Place place() const { return _place; }

        const Zsl * next() const { return _next; }

        bool valid() const
        {
                return (id() > 0) && (place().valid()) && (value()!=0) && ( (next() == 0) || (next()->valid()));
        }



        friend ostream & operator<<(ostream &  os, const Zsl & zsl);

        friend class ZslFactory;
};


class ZslFactory
{

private:
        const Net * _net;
        vector<  vector<  unordered_map<unsigned, Zsl *>  > > _negTable;
        vector<  vector<  unordered_map<unsigned, Zsl *>  > > _posTable;
        vector<Zsl *> _table;

public:
        ZslFactory(const Net & net):
                _net(&net),
                _negTable(net.numberOfPlaces()+1),
                _posTable(net.numberOfPlaces()+1),
                _table(1) {}

        virtual ~ZslFactory();

        const Zsl * getZsl(Place place, int value, const Zsl * zsl);
        const Zsl * getZsl(unsigned id) { if(id >= _table.size()) { return 0; } return _table[id]; }

        string printZsl(const Zsl * zsl) const
        {
                stringstream str;
                str << owner()->labelOfPlace(zsl->place()) << "," << zsl->value() << " -> ";
                if(zsl->next() == 0)
                {
                        str << "NULL";
                }
                else
                {
                        str << printZsl(zsl->next());
                }
                return str.str();
        }


        const Net * owner() const { return _net; }

        const Zsl * addZsl(const Zsl * zsl, Place p, int value);


        void printDot(const string & fileName) const;

        void printTable();
};




};
};

#endif /* ZSL_HH_ */