path: root/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.h

//===-- UniqueDWARFASTType.h ------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef lldb_UniqueDWARFASTType_h_
#define lldb_UniqueDWARFASTType_h_

// C Includes
// C++ Includes
#include <vector>

// Other libraries and framework includes
#include "llvm/ADT/DenseMap.h"

// Project includes
#include "lldb/Symbol/Declaration.h"
#include "DWARFDIE.h"

class UniqueDWARFASTType
{
public:
	//------------------------------------------------------------------
	// Constructors and Destructors
	//------------------------------------------------------------------
	UniqueDWARFASTType () :
        m_type_sp (),
        m_die (),
        m_declaration (),
        m_byte_size (-1) // Set to negative value to make sure we have a valid value
    {
    }

	UniqueDWARFASTType (lldb::TypeSP &type_sp,
                        const DWARFDIE &die,
                        const lldb_private::Declaration &decl,
                        int32_t byte_size) :
        m_type_sp (type_sp),
        m_die (die),
        m_declaration (decl),
        m_byte_size (byte_size)
    {
    }
    
    UniqueDWARFASTType (const UniqueDWARFASTType &rhs) :
        m_type_sp (rhs.m_type_sp),
        m_die (rhs.m_die),
        m_declaration (rhs.m_declaration),
        m_byte_size (rhs.m_byte_size)
    {
    }

	~UniqueDWARFASTType()
    {
    }

    UniqueDWARFASTType &
    operator= (const UniqueDWARFASTType &rhs)
    {
        if (this != &rhs)
        {
            m_type_sp = rhs.m_type_sp;
            m_die = rhs.m_die;
            m_declaration = rhs.m_declaration;
            m_byte_size = rhs.m_byte_size;
        }
        return *this;
    }

    lldb::TypeSP m_type_sp;
    DWARFDIE m_die;
    lldb_private::Declaration m_declaration;
    int32_t m_byte_size;
};

class UniqueDWARFASTTypeList
{
public:
    UniqueDWARFASTTypeList () :
        m_collection()
    {
    }
    
    ~UniqueDWARFASTTypeList ()
    {
    }
    
    uint32_t
    GetSize()
    {
        return (uint32_t)m_collection.size();
    }
    
    void
    Append (const UniqueDWARFASTType &entry)
    {
        m_collection.push_back (entry);
    }
    
    bool
    Find (const DWARFDIE &die,
          const lldb_private::Declaration &decl,
          const int32_t byte_size,
          UniqueDWARFASTType &entry) const;
    
protected:
    typedef std::vector<UniqueDWARFASTType> collection;
    collection m_collection;
};

class UniqueDWARFASTTypeMap
{
public:
    UniqueDWARFASTTypeMap () :
        m_collection ()
    {
    }
    
    ~UniqueDWARFASTTypeMap ()
    {
    }

    void
    Insert (const lldb_private::ConstString &name, 
            const UniqueDWARFASTType &entry)
    {
        m_collection[name.GetCString()].Append (entry);
    }

    bool
    Find (const lldb_private::ConstString &name,
          const DWARFDIE &die,
          const lldb_private::Declaration &decl,
          const int32_t byte_size,
          UniqueDWARFASTType &entry) const
    {
        const char *unique_name_cstr = name.GetCString();
        collection::const_iterator pos = m_collection.find (unique_name_cstr);
        if (pos != m_collection.end())
        {
            return pos->second.Find (die, decl, byte_size, entry);
        }
        return false;
    }

protected:
    // A unique name string should be used
    typedef llvm::DenseMap<const char *, UniqueDWARFASTTypeList> collection;
    collection m_collection;
};

#endif	// lldb_UniqueDWARFASTType_h_