path: root/lib/catalog/tag.h

/* This file is part of KDevelop
    Copyright (C) 2003 Roberto Raggi <roberto@tdevelop.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef TAG_H
#define TAG_H

#include <tqmap.h>
#include <tqvariant.h>
#include <tqshared.h>

class TQDataStream;

union TagFlags
{
    unsigned long flags;
    struct
    {
		unsigned long access:
                        3;
		unsigned long isVirtual:
                        1;
    }
    data;
} ;

class Tag
{
public:
    enum Kind
    {
	Kind_Unknown,

	Kind_Typedef = 1000,
	Kind_Namespace,
	Kind_UsingDirective,
	Kind_Base_class,
	Kind_Enum,
	Kind_Enumerator,
	Kind_Class,
	Kind_Struct,
	Kind_Union,
	Kind_VariableDeclaration,
	Kind_Variable,
	Kind_FunctionDeclaration,
	Kind_Function,
        Kind_NamespaceAlias,
        Kind_TranslationUnit,
    
	// ...

	Kind_Custom = 2000
    };

public:
    Tag();
    Tag( const Tag& source );
    ~Tag();
    
    operator bool() const {
        return kind() != Kind_Unknown && kind() != 0;
    }

    Tag& operator = ( const Tag& source );
    
    TQCString id() const
    {
        return data->id;
    }

    void setId( const TQCString& id )
    {
	detach();
        data->id = id;
    }

    int kind() const
    {
        return data->kind;
    }

    void setKind( int kind )
    {
	detach();
        data->kind = kind;
    }

    unsigned long flags() const
    {
        return data->flags;
    }

    void setFlags( unsigned long flags )
    {
	detach();
        data->flags = flags;
    }

    TQString fileName() const
    {
        return data->fileName;
    }

    void setFileName( const TQString& fileName )
    {
	detach();
        data->fileName = fileName;
    }

    TQString path( const TQString& sep = TQString::fromLatin1("::") ) const
    {
        TQString s = scope().join( sep );
        if( s.isNull() )
            return name();
	return s + sep + name();
    }

    TQString name() const
    {
        return data->name;
    }
    
    TQString comment() const {
        if( hasAttribute( "cmt" ) ) {
            return attribute( "cmt" ).asString();
        } else {
            return "";
        }
    }

    void setComment( const TQString& comment ) {
        setAttribute( "cmt", comment );
    }
    
    void setName( const TQString& name )
    {
	detach();
        data->name = name;
    }
    
    TQStringList scope() const
    {
        return data->scope;
    }

    void setScope( const TQStringList& scope )
    {
	detach();
        data->scope = scope;
    }

    void getStartPosition( int* line, int* column ) const
    {
	if( line ) *line = data->startLine;
	if( column ) *column = data->startColumn;
    }

    void setStartPosition( int line, int column )
    {
	detach();
	data->startLine = line;
	data->startColumn = column;
    }

    void getEndPosition( int* line, int* column ) const
    {
	if( line ) *line = data->endLine;
	if( column ) *column = data->endColumn;
    }

    void setEndPosition( int line, int column )
    {
	detach();
	data->endLine = line;
	data->endColumn = column;
    }

		TQString getSpecializationDeclaration() const {
			if( hasAttribute( "spc" ) )
				return data->attributes["spc"].asString();
			else
				return TQString();
		}

		bool hasSpecializationDeclaration() const {
			return data->attributes.contains( "spc" );
		}

		void setSpecializationDeclaration( const TQString& str ) {
			data->attributes["spc"] = str;
		}

	bool hasAttribute( const TQCString& name ) const
    {
	if( name == "kind" ||
	    name == "name" ||
	    name == "scope" ||
	    name == "fileName" ||
	    name == "startLine" ||
	    name == "startColumn" ||
	    name == "endLine" ||
	    name == "endColumn" )
	    return true;
        return data->attributes.contains( name );
    }

    TQVariant attribute( const TQCString& name ) const
    {
	if( name == "id" )
	    return data->id;
	else if( name == "kind" )
	    return data->kind;
	else if( name == "name" )
	    return data->name;
	else if( name == "scope" )
	    return data->scope;
	else if( name == "fileName" )
	    return data->fileName;
	else if( name == "startLine" )
	    return data->startLine;
	else if( name == "startColumn" )
	    return data->startColumn;
	else if( name == "endLine" )
	    return data->endLine;
	else if( name == "endColumn" )
	    return data->endColumn;
	else if( name == "prefix" )
	    return data->name.left( 2 );
        return data->attributes[ name ];
    }

    void setAttribute( const TQCString& name, const TQVariant& value )
    {
	detach();
	if( name == "id" )
	    data->id = value.toCString();
	else if( name == "kind" )
	    data->kind = value.toInt();
	else if( name == "name" )
	    data->name = value.toString();
	else if( name == "scope" )
	    data->scope = value.toStringList();
	else if( name == "fileName" )
	    data->fileName = value.toString();
	else if( name == "startLine" )
	    data->startLine = value.toInt();
	else if( name == "startColumn" )
	    data->startColumn = value.toInt();
	else if( name == "endLine" )
	    data->endLine = value.toInt();
	else if( name == "endColumn" )
	    data->endColumn = value.toInt();
	else
	    data->attributes[ name ] = value;
    }
    
    void addTemplateParam( const TQString& param , const TQString& def = "" ) {
        TQMap<TQCString, TQVariant>::iterator it = data->attributes.find( "tpl" );
        if( it != data->attributes.end() && (*it).type() == TQVariant::StringList ) {
        }else{
            it = data->attributes.insert( "tpl", TQVariant( TQStringList() ) );
        }
        
        TQStringList& l( (*it).asStringList() );
        l << param;
        l << def;
    }
    
    void load( TQDataStream& stream );
    void store( TQDataStream& stream ) const;

private:
    Tag copy();
    void detach();
    
private:
    struct TagData: public TQShared
    {
	TQCString id;
	int kind;
	unsigned long flags;
	TQString name;
	TQStringList scope;
	TQString fileName;
	int startLine, startColumn;
	int endLine, endColumn;
	TQMap<TQCString, TQVariant> attributes;
    } *data;
};

TQDataStream& operator << ( TQDataStream&, const Tag& );
TQDataStream& operator >> ( TQDataStream&, Tag& );

#endif