source/Core/FileSpecList.cpp

//===-- FileSpecList.cpp ----------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Stream.h"
#include <algorithm>

using namespace lldb_private;
using namespace std;

//------------------------------------------------------------------
// Default constructor
//------------------------------------------------------------------
FileSpecList::FileSpecList() :
    m_files()
{
}

//------------------------------------------------------------------
// Copy constructor
//------------------------------------------------------------------
FileSpecList::FileSpecList(const FileSpecList& rhs) :
    m_files(rhs.m_files)
{
}

//------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------
FileSpecList::~FileSpecList()
{
}

//------------------------------------------------------------------
// Assignment operator
//------------------------------------------------------------------
const FileSpecList&
FileSpecList::operator= (const FileSpecList& rhs)
{
    if (this != &rhs)
        m_files = rhs.m_files;
    return *this;
}

//------------------------------------------------------------------
// Append the "file_spec" to the end of the file spec list.
//------------------------------------------------------------------
void
FileSpecList::Append(const FileSpec &file_spec)
{
    m_files.push_back(file_spec);
}

//------------------------------------------------------------------
// Only append the "file_spec" if this list doesn't already contain
// it.
//
// Returns true if "file_spec" was added, false if this list already
// contained a copy of "file_spec".
//------------------------------------------------------------------
bool
FileSpecList::AppendIfUnique(const FileSpec &file_spec)
{
    collection::iterator pos, end = m_files.end();
    if (find(m_files.begin(), end, file_spec) == end)
    {
        m_files.push_back(file_spec);
        return true;
    }
    return false;
}

//------------------------------------------------------------------
// Clears the file list.
//------------------------------------------------------------------
void
FileSpecList::Clear()
{
    m_files.clear();
}

//------------------------------------------------------------------
// Dumps the file list to the supplied stream pointer "s".
//------------------------------------------------------------------
void
FileSpecList::Dump(Stream *s, const char *separator_cstr) const
{
    collection::const_iterator pos, end = m_files.end();
    for (pos = m_files.begin(); pos != end; ++pos)
    {
        pos->Dump(s);
        if (separator_cstr && ((pos + 1) != end))
            s->PutCString(separator_cstr);
    }
}

//------------------------------------------------------------------
// Find the index of the file in the file spec list that matches
// "file_spec" starting "start_idx" entries into the file spec list.
//
// Returns the valid index of the file that matches "file_spec" if
// it is found, else UINT32_MAX is returned.
//------------------------------------------------------------------
size_t
FileSpecList::FindFileIndex (size_t start_idx, const FileSpec &file_spec, bool full) const
{
    const size_t num_files = m_files.size();

    // When looking for files, we will compare only the filename if the
    // FILE_SPEC argument is empty
    bool compare_filename_only = file_spec.GetDirectory().IsEmpty();

    for (size_t idx = start_idx; idx < num_files; ++idx)
    {
        if (compare_filename_only)
        {
            if (m_files[idx].GetFilename() == file_spec.GetFilename())
                return idx;
        }
        else
        {
            if (FileSpec::Equal (m_files[idx], file_spec, full))
                return idx;
        }
    }

    // We didn't find the file, return an invalid index
    return UINT32_MAX;
}

//------------------------------------------------------------------
// Returns the FileSpec object at index "idx". If "idx" is out of
// range, then an empty FileSpec object will be returned.
//------------------------------------------------------------------
const FileSpec &
FileSpecList::GetFileSpecAtIndex(size_t idx) const
{

    if (idx < m_files.size())
        return m_files[idx];
    static FileSpec g_empty_file_spec;
    return g_empty_file_spec;
}

const FileSpec *
FileSpecList::GetFileSpecPointerAtIndex(size_t idx) const
{
    if (idx < m_files.size())
        return &m_files[idx];
    return NULL;
}

//------------------------------------------------------------------
// Return the size in bytes that this object takes in memory. This
// returns the size in bytes of this object's member variables and
// any FileSpec objects its member variables contain, the result
// doesn't not include the string values for the directories any
// filenames as those are in shared string pools.
//------------------------------------------------------------------
size_t
FileSpecList::MemorySize () const
{
    size_t mem_size = sizeof(FileSpecList);
    collection::const_iterator pos, end = m_files.end();
    for (pos = m_files.begin(); pos != end; ++pos)
    {
        mem_size += pos->MemorySize();
    }

    return mem_size;
}

//------------------------------------------------------------------
// Return the number of files in the file spec list.
//------------------------------------------------------------------
size_t
FileSpecList::GetSize() const
{
    return m_files.size();
}

size_t
FileSpecList::GetFilesMatchingPartialPath (const char *path, bool dir_okay, FileSpecList &matches)
{
#if 0  // FIXME: Just sketching...
    matches.Clear();
    FileSpec path_spec = FileSpec (path);
    if (path_spec.Exists ())
    {
        FileSpec::FileType type = path_spec.GetFileType();
        if (type == FileSpec::eFileTypeSymbolicLink)
            // Shouldn't there be a Resolve on a file spec that real-path's it?
        {
        }

        if (type == FileSpec::eFileTypeRegular
            || (type == FileSpec::eFileTypeDirectory && dir_okay))
        {
            matches.Append (path_spec);
            return 1;
        }
        else if (type == FileSpec::eFileTypeDirectory)
        {
            // Fill the match list with all the files in the directory:

        }
        else
        {
            return 0;
        }

    }
    else
    {
        ConstString dir_name = path_spec.GetDirectory();
        Constring file_name = GetFilename();
        if (dir_name == NULL)
        {
            // Match files in the CWD.
        }
        else
        {
            // Match files in the given directory:

        }
    }
#endif
    return 0;
}