LintProject - Improving the Usability of PC-Lint with Visual C++ Solutions and Projects

/************************************************************************
 *
 *  Description : CSolutionFileReaderImpl - implementation class for
 *                CSolutionFileReader.
 *
 *     (c) Copyright 2000-2008 by Anna-Jayne Metcalfe (anna@riverblade.co.uk)
 *     and Beth Mackenzie (beth@riverblade.co.uk) / Riverblade Limited
 *
 *  Licence Terms:
 *
 *     This code may be freely reused, subject to the licence terms below.
 *     Please do let us know of any bugs you find or improvements you make,
 *     so that we can pass them on to the rest of the development community.
 *
 *     This code is free software; you can redistribute it and/or
 *     modify it under the terms of the Code Project Open License (CPOL)
 *     version 1.0 (http://www.codeproject.com/info/cpol10.aspx).
 *
 *     This code 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
 *     Code Project Open Licence for further details.
 *
 ************************************************************************
 *    $Archive: /Projects/Applications/LintProject/Development/Shared/SolutionFileReaderImpl.h $
 *   $Revision: 2 $
 *       $Date: 22/02/08 20:50 $
 *     $Author: Anna $
 * 
 * $Nokeywords: $
 ************************************************************************/

/// \file	
/// \brief Implementation class for CSolutionFileReader.

#pragma once

#ifdef _UTILS_LOCAL_INCLUDE
	#include "SplitPath.h"
	#include "StringUtils.h"
	#include "PathUtils.h"
	#include "FileUtils.h"
#else
	#include <Utils\Include\SplitPath.h>
	#include <Utils\Include\StringUtils.h>
	#include <Utils\Include\PathUtils.h>
	#include <Utils\Include\FileUtils.h>
#endif

#include "ProjectFileReader.h"

#include "SolutionFileReader.h"


namespace Riverblade
{
	namespace Libraries
	{
		namespace AddInSolutionModel
		{
			//lint -esym(1925, *::CSolutionFileReaderProjectImpl::*)		(Elective Note -- Symbol 'CSolutionFileReaderProjectImpl a public data member -- Effective C++ #20)

			/// \brief Implementation class to describe the properties of a project within a solution or workspace file.
			///
			class CSolutionFileReaderProjectImpl
			{
				public:
					/// \brief Default constructor
					///
					CSolutionFileReaderProjectImpl(void)
						:	m_sProject(_T("") ),
							m_sPathName(_T("") ),
							m_sGUID(_T("") ),
							m_mapConfigurations()
					{
					}


					/// \brief Copy constructor
					///
					///	\param	src				A reference to the object to copy from.
					///
					CSolutionFileReaderProjectImpl(const CSolutionFileReaderProjectImpl& src)
						:	m_sProject(src.m_sProject),
							m_sPathName(src.m_sPathName ),
							m_sGUID(src.m_sGUID),
							m_mapConfigurations()
					{
						CopyConfigurations(src);
					}


					/// \brief Class destructor
					///
					virtual	~CSolutionFileReaderProjectImpl(void)
					{
					}


				// Data members
				public:
					CString						m_sProject;					///< The name of the project.
					CString						m_sPathName;				///< The pathname of the project.
					CString						m_sGUID;					///< The project GUID (if applicable).
					CAtlMap<CString, CString>	m_mapConfigurations;		///< Map of solution configurations to project configuration strings.


				// Operators
				public:
					/// \brief Assignment operator
					///
					///	\param	src				A reference to the object to copy from.
					///	\return					A reference to this object.
					///
					CSolutionFileReaderProjectImpl& operator=(const CSolutionFileReaderProjectImpl& src)
					{
						if (this != &src)
						{
							m_sProject	= src.m_sProject;
							m_sGUID		= src.m_sGUID;
							m_sPathName	= src.m_sPathName;

							CopyConfigurations(src);
						}
						return *this;
					}


				// Operations
				public:
					/// \brief Define the mapping between the given solution and project configurations.
					///
					/// \param	sSolutionConfig		The name of the solution configuration.
					/// \param	sProjectConfig		The name of the project configuration it uses.
					///
					void AddConfiguration(const CString& sSolutionConfig, const CString& sProjectConfig)
					{
						m_mapConfigurations[sSolutionConfig] = sProjectConfig;
					}


					/// \brief return the project configuration string associated with the given solution configuration.
					///
					/// \param	sSolutionConfig		The name of the solution configuration.
					/// \return						The name of the project configuration it uses.
					///
					CString GetProjectConfiguration(const CString& sSolutionConfig) const
					{
						CString sProjectConfig;
						(void)m_mapConfigurations.Lookup(sSolutionConfig, sProjectConfig);
						if (sProjectConfig.IsEmpty() )
						{
							// Needed for VS6 projects, unfortunately
							sProjectConfig = sSolutionConfig;
						}
						return sProjectConfig;
					}


				// Implementation
				private:
					/// \brief Implementation method to copy all configuration data from a given source object.
					///
					/// \param	src				A reference to the object to copy.
					///
					void CopyConfigurations(const CSolutionFileReaderProjectImpl& src)
					{
						m_mapConfigurations.RemoveAll();

						POSITION pos = src.m_mapConfigurations.GetStartPosition();
						while (NULL != pos)
						{
							CString sSolutionConfig, sProjectConfig;
							src.m_mapConfigurations.GetNextAssoc(pos, sSolutionConfig, sProjectConfig);

							m_mapConfigurations[sSolutionConfig] = sProjectConfig;
						}
					}
			};

			typedef	CAtlMap<CString, CSolutionFileReaderProjectImpl> CMapStringToProject;		///< Maps project name to the corresponding CProjectInfo object.


			/// \brief An abstract base class used by by CSolutionFileReader for classes used to parse individual solution/workspace file formats.
			///
			class CSolutionFileReaderImpl
			{
				public:
					/// \brief Default constructor.
					///
					CSolutionFileReaderImpl(void)
						:	m_sPathName(),
							m_arrayProjectFilePathNames(),
							m_mapProjects(),
							m_arraySolutionConfigs()
					{
					}

					
					/// \brief Class destructor.
					///
					virtual ~CSolutionFileReaderImpl(void)
					{
					}


					/// \brief Read the given solution or workspace file.
					///
					/// \param	sPathName		The pathname of the file.
					/// \return					\em true if the file was parsed successfully; \em false otherwise.
					///
					virtual bool Read(const CString& sPathName)
					{
						m_sPathName = sPathName;

						// First read the entire file into a buffer for processing
						CAtlArray<CString> arrayLines;
						const HRESULT hr = Utils::ReadTextFile(sPathName, arrayLines);
						DBG_UNREFERENCED_LOCAL_VARIABLE(hr);

						ATLASSERT(SUCCEEDED(hr) );

						if (arrayLines.GetCount() > 0)
						{
							// The file exists and has been read successfully
							// From here on in its up to the parser...
							return Parse(arrayLines);
						}
						return false;
					}


					/// \brief Parse the contents of a solution or workspace file.
					///
					/// Derived classes must implement this method.
					///
					/// \param	arrayLines		The contents of the file.
					/// \return					\em true if the file was parsed successfully; \em false otherwise.
					///
					virtual bool Parse(const CAtlArray<CString>& arrayLines) = 0;


					/// \brief Return an array of the pathnames of the projects found in the solution
					///
					/// \param	rarrayProjectFilePathNames	A reference to an array which will receive the pathnames of
					///										the projects found.
					/// \return								The number of pathnames returned in rarrayProjectFilePathNames.
					///
					virtual size_t GetProjectFilePathNames(CAtlArray<CString>& rarrayProjectFilePathNames) const
					{
						(void)rarrayProjectFilePathNames.Append(m_arrayProjectFilePathNames);

						return rarrayProjectFilePathNames.GetCount();
					}


					/// \brief Return an array of the names of the configurations found in the solution
					///
					/// \param	rarrayConfigurations	A reference to an array which will receive the names of
					///									the configurations found.
					/// \return							The number of configuration names returned in rarrayConfigurations.
					///
					virtual size_t GetConfigurations(CAtlArray<CString>& rarrayConfigurations) const
					{
						rarrayConfigurations.RemoveAll();

						(void)rarrayConfigurations.Append(m_arraySolutionConfigs);

						return rarrayConfigurations.GetCount();
					}


					/// \brief Determine whether the given solution configuration name is valid.
					///
					///	\param	sConfiguration	A string identifying the solution configuration.
					/// \return					\em true if the configuration is valid; \em false otherwise.
					///
					virtual bool IsValidConfiguration(const CString& sConfiguration) const
					{
						for (size_t n = 0; n < m_arraySolutionConfigs.GetCount(); n++)
						{
							if (sConfiguration == m_arraySolutionConfigs[n])
							{
								return true;
							}
						}
						return false;
					}


					/// \brief Retrieve the configuration string for the configuration of a project corresponding to the given solution/workspace configuration.
					///
					/// \param	sPathName			The pathname of the project.
					/// \param	sSolutionConfig		The name of the solution configuration.
					/// \return						The configuration string corresponding to sSolutionConfig, 
					///								or an empty string if one cannot be found.
					///
					virtual CString GetProjectConfigurationFromPathName(const CString& sPathName, const CString& sSolutionConfig) const
					{
						POSITION pos = m_mapProjects.GetStartPosition();
						while (NULL != pos)
						{
							CString sProjectName;
							CSolutionFileReaderProjectImpl info;
							m_mapProjects.GetNextAssoc(pos, sProjectName, info);

							if (0 == sPathName.CompareNoCase(info.m_sPathName) )
							{
								return info.GetProjectConfiguration(sSolutionConfig);
							}
						}
						return _T("");
					}



				protected:
					CString				m_sPathName;						///< The pathname of the solution or workspace
					CAtlArray<CString>	m_arrayProjectFilePathNames;		///< An array of project file pathnames
					CMapStringToProject	m_mapProjects;						///< Map of project pathames to CProjectInfo objects.
					CAtlArray<CString>	m_arraySolutionConfigs;				///< Array of solution configuration names.
			};


		};	// namespace AddInSolutionModel
	};	// namespace Libraries
};	//namespace Riverblade