---

element.h

Go to the documentation of this file.

#ifndef FILE_ELEMENT_H
#define FILE_ELEMENT_H

#include <string>
#include <map>
#include <vector>
#include <memory>
#include <iostream>
#include "func.h"

class Element
{
public:
        Element(const char* name);
        /**
         * Assign position to this element
         * Return next pos
         */
        virtual int AssignPos(int currPos)=0;
        int GetLength() const { return len; }
        virtual void Output(ostream& out,Element* sel)=0;
protected:
        std::string name;
        int position;
        int len;
};

Element::Element(const char* _name):name(_name),position(-1),len(-1)
{
}

class Elements
{
public:
        void Add(Element* e);
        ~Elements();
private:
        friend class ComplexElement;
        typedef std::vector<Element*> TV;
        TV v;
};

Elements::~Elements()
{
        for(TV::iterator i=v.begin(); i != v.end(); ++i)
                delete (*i);
}

void Elements::Add(Element* e)
{
        v.push_back(e);
}

class ComplexElement: public Element
{
public:
        ComplexElement(const char* name,enum ComplexType type,
                        Elements* elements);
        ~ComplexElement();
        static ComplexElement* Find(const char* name);
        int AssignPos(int currPos);
        void Process(ostream& out);
        void Output(ostream& out,Element* sel);
private:
        enum ComplexType type;
        std::auto_ptr<Elements> elements;
        static std::map<std::string,ComplexElement*> all;
};

std::map<std::string,ComplexElement*> ComplexElement::all;

ComplexElement::ComplexElement(const char* _name,enum ComplexType _type,
                        Elements* _elements):
Element(_name),type(_type),elements(_elements)
{
        all[name] = this;
}

ComplexElement::~ComplexElement()
{
        all.erase(name);
}

ComplexElement* ComplexElement::Find(const char* name)
{
        if (all.find(name) == all.end())
                return NULL;
        return all[name];
}

int ComplexElement::AssignPos(int currPos)
{
        position = currPos;
        
        Elements::TV::iterator i = elements->v.begin();
        Elements::TV::iterator end = elements->v.end();
        int pos = currPos;
        int maxPos = currPos;
        for(; i!= end;++i)
        {
                pos = (*i)->AssignPos(pos);
                if (type==Union)
                {
                        // union, calc maximun for result and then reset
                        maxPos = maxPos > pos ? maxPos : pos;
                        pos = currPos;
                }
                else
                {
                        maxPos = pos;
                }
        }
        
        len = maxPos - position;
        
        return maxPos;
}

void ComplexElement::Output(ostream& out,Element* sel)
{
        Elements::TV::iterator i = elements->v.begin();
        Elements::TV::iterator end = elements->v.end();
        out << "Complex " << name << " pos:" << position << " len:" << len << " {" << endl;
        for(; i!= end;++i)
        {
                (*i)->Output(out,NULL);
        }
        out << "};" << endl;
}

void ComplexElement::Process(ostream& out)
{
        AssignPos(0);
        Output(out,NULL);
}

class DefinedElement: public Element
{
public:
        DefinedElement(const char* name,ComplexElement* type,int n);
        int AssignPos(int currPos);
        void Output(ostream& out,Element* sel);
private:
        ComplexElement* type;
        int n;
};

DefinedElement::DefinedElement(const char* name,ComplexElement* _type,int _n):
        Element(name),type(_type),n(_n)
{
        
}

int DefinedElement::AssignPos(int currPos)
{
        position = currPos;
        len = type->GetLength();
        return currPos + len;
}

void DefinedElement::Output(ostream& out,Element* sel)
{
        out << "Defined " << name << " pos:" << position << " len:" << len << " {" << endl;
        type->Output(out,NULL);
        out << "};" << name << "{" << endl;
}

class SimpleElement: public Element
{
public:
        SimpleElement(const char* name,bool isSigned,int size,int n);
        int AssignPos(int currPos);
        void Output(ostream& out,Element* sel);
private:
        bool isSigned;
        int size,n;
};

SimpleElement::SimpleElement(const char* name,bool _isSigned,int _size,int _n):
  Element(name),isSigned(_isSigned),size(_size),n(_n)
{
}

int SimpleElement::AssignPos(int currPos)
{
        position = currPos;
        len = size*(n==0?1:n);
        return currPos + len;
}

void SimpleElement::Output(ostream& out,Element* sel)
{
        out << "Simple " << name << " pos:" << position << " len:" << len << ";" << endl;
}

// just skip some bytes for paddind
class PaddingElement: public Element
{
public:
        PaddingElement(const char* name,int size);
        int AssignPos(int currPos);
        void Output(ostream& out,Element* sel);
private:
        int size;
};

PaddingElement::PaddingElement(const char* name,int _size):
        Element(name),size(_size)
{
        
}

int PaddingElement::AssignPos(int currPos)
{
        position = currPos;
        len = size;
        return currPos + len;
}

void PaddingElement::Output(ostream& out,Element* sel)
{
        out << "Padding " << name << " pos:" << position << " len:" << len << ";" << endl;
}

#endif // FILE_ELEMENT_H

---