AttributeParser.h

Go to the documentation of this file.

// $Id: AttributeParser.h 241 2006-07-05 07:29:52Z bingmann $

#ifndef VGS_AttributeParser_H
#define VGS_AttributeParser_H

#include <string>
#include "AnyType.h"
#include "AttributeProperties.h"

#include "AttributeBlob.h"

namespace VGServer {

class ParseNode
{
protected:
    inline ParseNode()
    { }

    ParseNode(const ParseNode &pn);
    
public:
    virtual ~ParseNode()
    { }

    virtual bool getValue(AnyType &dest, const class GraphContainer &gc, const class Changelist &cl,
                          vertex_or_edge_t voe, unsigned int vid1, unsigned int vid2) const = 0;

    virtual bool getConstVal(AnyType *dest) const = 0;

    virtual std::string toString() const = 0;
};

class AttributeSelectorList : private std::vector<const class ParseNode*>,
                              public AttributePropertiesList
{
private:
    typedef std::vector<const class ParseNode*> sellist;

    typedef AttributePropertiesList attrlist;

public:
    ~AttributeSelectorList()
    {
        clear();
    }

    void clear() {
        attrlist::clear();
        for(sellist::const_iterator i = sellist::begin(); i != sellist::end(); i++) {
            delete *i;
        }
        sellist::clear();
    }
    
    void        selectStar(const AttributePropertiesList &otherlist, vertex_or_edge_t voe);

    void        addAttrsel(const class ParseNode *attrsel);

    bool        parseString(const std::string &input, const class GraphProperties &gp, vertex_or_edge_t voe);

    std::string toString() const;

    size_t size() const {
        assert(sellist::size() == attrlist::size());
        return sellist::size();
    }

    inline const class ParseNode* getSelector(unsigned int i) const
    { return sellist::operator[](i); }

    inline const class AttributeProperties& getProperties(unsigned int i) const
    { return attrlist::operator[](i); }

    inline unsigned int processVertexAttributeBlob(AttributeVertexTinyBlob &attrblob,
                                                   const class GraphContainer &gc,
                                                   const class Changelist &cl, unsigned int vid) const
    {
        unsigned int p = defbytes;
        attrblob.zero(0, p);
        
        for(unsigned int ai = 0; ai < size(); ai++)
        {
            // Calculate the value of the attribute selector
            AnyType attrval(ATTRTYPE_INVALID);

            getSelector(ai)->getValue(attrval, gc, cl, VE_VERTEX, vid, 0);

            // bools are in the default bitfield
            if (getProperties(ai).getType() == ATTRTYPE_BOOL) {
                attrblob.putBool(0, ai, attrval.getInteger() != 0);
            }
            // check if it's the default value.
            else if (attrval == getProperties(ai)) {
                // set default bit
                attrblob.putBool(0, ai, true);
            }
            else {
                // otherwise append the value.
                attrblob.putAnyType(p, attrval);
                p += attrval.getValueLength();
            }
        }

        return p;
    }

    inline unsigned int processEdgeAttributeBlob(AttributeVertexTinyBlob &attrblob,
                                                 const class GraphContainer &gc,
                                                 const class Changelist &cl, unsigned int esrc, unsigned etgt) const
    {
        unsigned int p = defbytes;
        attrblob.zero(0, p);
        
        for(unsigned int ai = 0; ai < size(); ai++)
        {
            // Calculate the value of the attribute selector
            AnyType attrval(ATTRTYPE_INVALID);

            getSelector(ai)->getValue(attrval, gc, cl, VE_EDGE, esrc, etgt);

            // bools are in the default bitfield
            if (getProperties(ai).getType() == ATTRTYPE_BOOL) {
                attrblob.putBool(0, ai, attrval.getInteger() != 0);
            }
            // check if it's the default value.
            else if (attrval == getProperties(ai)) {
                // set default bit
                attrblob.putBool(0, ai, true);
            }
            else {
                // otherwise append the value.
                attrblob.putAnyType(p, attrval);
                p += attrval.getValueLength();
            }
        }

        return p;
    }

};

class FilterRoot
{
private:
    const class ParseNode       *filter;

    vertex_or_edge_t    vertexoredge;

public:
    FilterRoot()
        : filter(NULL)
    {
    }

    ~FilterRoot()
    {
        if (filter)
            delete filter;
    }

    bool        parseString(const std::string &input, const class GraphProperties &gp);

    std::string toString() const;

    bool        isEmpty() const
    { return (filter == NULL); }

    vertex_or_edge_t    getType() const
    { return vertexoredge; }

    inline bool eval_vertex(const class GraphContainer &gc, const class Changelist &cl,
                            unsigned int vid) const
    {
        AnyType at(ATTRTYPE_INVALID);

        assert(filter);
        filter->getValue(at, gc, cl, VE_VERTEX, vid, 0);
        return (at.getInteger() != 0);
    }

    inline bool eval_edge(const class GraphContainer &gc, const class Changelist &cl,
                          unsigned int vidsrc, unsigned int vidtgt) const
    {
        AnyType at(ATTRTYPE_INVALID);

        assert(filter);
        filter->getValue(at, gc, cl, VE_EDGE, vidsrc, vidtgt);
        return (at.getInteger() != 0);
    }
};

class AttributeParseException : public GraphException
{
public:
    inline AttributeParseException(const std::string &s) throw()
        : GraphException(s)
    { }
};


} // namespace VGServer

#endif // VGS_AttributeParser_H

---