buffernode.h

Go to the documentation of this file.

/*
 | Author: Michael Schmidt;
 |         Gunnar Jehl 
 |
 | ************************* SOFTWARE LICENSE AGREEMENT ***********************
 | This source code is published under the BSD License.
 |
 | See file 'LICENSE.txt' that comes with this distribution or
 | http://dbis.informatik.uni-freiburg.de/index.php?project=GCX/license.php
 | for the full license agreement.
 |
 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 | POSSIBILITY OF SUCH DAMAGE.
 | ****************************************************************************
*/

#ifndef BUFFERNODE_H
#define BUFFERNODE_H

#define TYPE_TAG        true

#define TYPE_PCDATA     false

#include <vector>
#include <sstream>
#include "tagmap.h"
#include "tagnode.h"
#include "charnode.h"
#include "intmultiset.h"
#include "role.h"

// forward declarations
class PathExpression;
struct BufferNode;

struct BufferNode {
    BufferNode(const char *_data, BufferNode * _parent);

     BufferNode(TAG _tag, BufferNode * _parent);

     BufferNode(const char *_data, BufferNode * _parent,
                vector < unsigned >*_cumulative_roles,
                vector < unsigned >*_non_cumulative_roles);

     BufferNode(TAG _tag, BufferNode * _parent,
                vector < unsigned >*_cumulative_roles,
                vector < unsigned >*_non_cumulative_roles);

     virtual ~ BufferNode();

    void addChild(BufferNode * child);

    void appendRoles(vector < unsigned >*_cumulative_roles,
                     vector < unsigned >*_non_cumulative_roles);

    void print(OutputStream & eos);

    void printNoSubnodes(OutputStream & dos);

    void debugPrint(OutputStream & dos);

    void debugPrintCompleteBuffer(OutputStream & dos);

    const char *getPCDataRepresentation();

    void getPCDataRepresentation(std::ostringstream & s);

    inline void close() {
        ((TagNode *) node)->is_closed = true;
    } inline bool isClosed() {
        return ((TagNode *) node)->is_closed;
    }

    inline void lock() {
        is_locked = true;
    }

    inline void unlock() {
        is_locked = false;
    }

    inline bool isLocked() {
        return is_locked;
    }

    inline bool isRoot() {
        return type == TYPE_TAG && ((TagNode *) node)->tag == TAGID_ROOT;
    }

    bool isMarked();

    bool isCumulativeMarked();

    bool hasCumulativeMarkedAncestor();

    bool hasNoMarkedAndNoLockedDos();

    void removeRoleFromNode(Role * role);

    void clear();

    void clearSubtreeIfPossible();

    bool type;

    BufferNode *parent;

    BufferNode *r_sibling;

#ifdef ROLE_REFCOUNT

    unsigned cumulative_roles;
#else

    IntMultiSet *cumulative_roles;
#endif // #ifdef ROLE_REFCOUNT

#ifdef ROLE_REFCOUNT

    unsigned non_cumulative_roles;
#else

    IntMultiSet *non_cumulative_roles;
#endif // #ifdef ROLE_REFCOUNT

    void *node;

    bool is_locked;
};

#endif // BUFFERNODE_H

---