strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/rdbmaker/source/codemaker/dependency.cxx
Jens-Heiner Rechtien 5da739c80b INTEGRATION: CWS warnings01 (1.4.18); FILE MERGED 
2005/09/23 00:23:50 sb 1.4.18.2: RESYNC: (1.4-1.5); FILE MERGED
2005/09/01 07:48:38 sb 1.4.18.1: #i53898# Made code warning-free.
2006-06-20 03:09:32 +00:00

346 lines
9.5 KiB
C++
Raw Blame History

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dependency.cxx,v $
*
* $Revision: 1.6 $
*
* last change: $Author: hr $ $Date: 2006-06-20 04:09:32 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _OSL_INTERLOCK_H_
#include <osl/interlck.h>
#endif
#ifndef _RTL_ALLOC_H_
#include <rtl/alloc.h>
#endif
#ifndef _CODEMAKER_DEPENDENCY_HXX_
#include <codemaker/dependency.hxx>
#endif
using namespace rtl;
TypeDependency::TypeDependency()
{
m_pImpl = new TypeDependencyImpl();
acquire();
}
TypeDependency::~TypeDependency()
{
release();
}
void TypeDependency::acquire()
{
osl_incrementInterlockedCount(&m_pImpl->m_refCount);
}
void TypeDependency::release()
{
if (0 == osl_decrementInterlockedCount(&m_pImpl->m_refCount))
{
delete m_pImpl;
}
}
sal_Bool TypeDependency::insert(const OString& type, const OString& depend, sal_uInt16 use)
{
sal_Bool ret = sal_False;
if (type.getLength() > 0 && depend.getLength() > 0)
{
if (m_pImpl->m_dependencies.count(type) > 0)
{
TypeUsing typeUsing(depend, use);
TypeUsingSet::iterator iter;
if ((iter = m_pImpl->m_dependencies[type].find(typeUsing)) != m_pImpl->m_dependencies[type].end())
{
(((TypeUsing *) &(*iter))->m_use) = (*iter).m_use | use;
} else
{
m_pImpl->m_dependencies[type].insert(typeUsing);
}
} else
{
TypeUsing typeUsing(depend, use);
TypeUsingSet tmpSet;
tmpSet.insert(typeUsing);
m_pImpl->m_dependencies[type]=tmpSet;
}
}
return ret;
}
TypeUsingSet TypeDependency::getDependencies(const OString& type)
{
if (type.getLength() > 0)
{
if (m_pImpl->m_dependencies.count(type) > 0)
{
return m_pImpl->m_dependencies[type];
}
}
return TypeUsingSet();
}
sal_Bool TypeDependency::lookupDependency(const OString& type, const OString& depend, sal_uInt16 use)
{
sal_Bool ret = sal_False;
if (type.getLength() > 0 && depend.getLength() > 0)
{
if (m_pImpl->m_dependencies.count(type) > 0)
{
TypeUsingSet::const_iterator iter = m_pImpl->m_dependencies[type].begin();
while (iter != m_pImpl->m_dependencies[type].end())
{
if (depend == (*iter).m_type &&
(use & (*iter).m_use))
{
ret = sal_True;
break;
}
iter++;
}
} else
{
ret = sal_False;
}
}
return ret;
}
sal_Bool TypeDependency::hasDependencies(const OString& type)
{
if (type.getLength() > 0)
{
if (m_pImpl->m_dependencies.count(type) > 0)
{
return sal_True;
}
}
return sal_False;
}
void TypeDependency::setGenerated(const OString& type, sal_uInt16 genFlag)
{
// m_pImpl->m_generatedTypes.insert(type);
if (m_pImpl->m_generatedTypes.count(type) > 0)
m_pImpl->m_generatedTypes[type]= m_pImpl->m_generatedTypes[type] | genFlag;
else
m_pImpl->m_generatedTypes[type]=genFlag;
}
sal_Bool TypeDependency::isGenerated(const OString& type, sal_uInt16 genFlag)
{
/*
if (m_pImpl->m_generatedTypes.count(type) > 0)
return sal_True;
return sal_False;
*/
if (m_pImpl->m_generatedTypes.count(type) > 0 &&
m_pImpl->m_generatedTypes[type] & genFlag)
{
return sal_True;
}
return sal_False;
}
static sal_Bool checkFieldDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
TypeReader& reader, const OString& type)
{
sal_uInt32 count = reader.getFieldCount();
if (count == 0 || reader.getTypeClass() == RT_TYPE_ENUM)
return sal_True;
OString fieldType;
for (sal_uInt16 i=0; i < count; i++)
{
fieldType = reader.getFieldType(i);
if (fieldType.getLength() > 0)
{
dependencies.insert(type, fieldType, TYPEUSE_MEMBER);
checkTypeDependencies(typeMgr, dependencies, fieldType);
}
}
return sal_True;
}
static sal_Bool checkMethodDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
TypeReader& reader, const OString& type)
{
sal_uInt32 count = reader.getMethodCount();
if (count == 0)
return sal_True;
OString returnType, paramType, excType;
sal_uInt32 paramCount = 0;
sal_uInt32 excCount = 0;
RTParamMode paramMode = RT_PARAM_INVALID;
for (sal_uInt16 i=0; i < count; i++)
{
returnType = reader.getMethodReturnType(i);
dependencies.insert(type, returnType, TYPEUSE_RETURN);
checkTypeDependencies(typeMgr, dependencies, returnType);
paramCount = reader.getMethodParamCount(i);
excCount = reader.getMethodExcCount(i);
sal_uInt16 j;
for (j=0; j < paramCount; j++)
{
paramType = reader.getMethodParamType(i, j);
paramMode = reader.getMethodParamMode(i, j);
switch (paramMode)
{
case RT_PARAM_IN:
dependencies.insert(type, paramType, TYPEUSE_INPARAM);
break;
case RT_PARAM_OUT:
dependencies.insert(type, paramType, TYPEUSE_OUTPARAM);
break;
case RT_PARAM_INOUT:
dependencies.insert(type, paramType, TYPEUSE_INOUTPARAM);
break;
default:
break;
}
checkTypeDependencies(typeMgr, dependencies, paramType);
}
for (j=0; j < excCount; j++)
{
excType = reader.getMethodExcType(i, j);
dependencies.insert(type, excType, TYPEUSE_EXCEPTION);
checkTypeDependencies(typeMgr, dependencies, excType);
}
}
return sal_True;
}
static sal_Bool checkReferenceDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
TypeReader& reader, const OString& type)
{
sal_uInt32 count = reader.getReferenceCount();
if (count == 0)
return sal_True;
OString referenceName;
for (sal_uInt16 i=0; i < count; i++)
{
referenceName = reader.getReferenceName(i);
dependencies.insert(type, referenceName, TYPEUSE_NORMAL);
checkTypeDependencies(typeMgr, dependencies, referenceName);
}
return sal_True;
}
sal_Bool checkTypeDependencies(TypeManager& typeMgr, TypeDependency& dependencies, const OString& type, sal_Bool bDepend)
{
if (!typeMgr.isValidType(type))
return sal_False;
if (dependencies.hasDependencies(type))
return sal_True;
TypeReader reader = typeMgr.getTypeReader(type);
if ( !reader.isValid() )
{
if (type.equals("/"))
return sal_True;
else
return sal_False;
}
if ( bDepend && reader.getTypeClass() == RT_TYPE_MODULE)
{
checkFieldDependencies(typeMgr, dependencies, reader, type);
return sal_True;
}
for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
OString superType(reader.getSuperTypeName(i));
dependencies.insert(type, superType, TYPEUSE_SUPER);
checkTypeDependencies(typeMgr, dependencies, superType);
}
if (reader.getTypeClass() == RT_TYPE_INTERFACE)
{
dependencies.insert(type, "com/sun/star/uno/RuntimeException", TYPEUSE_EXCEPTION);
dependencies.insert(type, "com/sun/star/uno/TypeClass", TYPEUSE_NORMAL);
checkTypeDependencies(typeMgr, dependencies, "com/sun/star/uno/RuntimeException", bDepend);
}
checkFieldDependencies(typeMgr, dependencies, reader, type);
checkMethodDependencies(typeMgr, dependencies, reader, type);
checkReferenceDependencies(typeMgr, dependencies, reader, type);
// make the scope modules as dependencies
sal_Int32 nPos = type.lastIndexOf( '/' );
if ( nPos >= 0 )
{
OString aScope( type.copy( 0, nPos ) );
OStringBuffer tmpBuf(aScope.getLength());
nPos = 0;
do
{
tmpBuf.append(aScope.getToken(0, '/', nPos));
dependencies.insert(type, tmpBuf.getStr(), TYPEUSE_SCOPE);
tmpBuf.append('/');
} while( nPos != -1 );
}
return sal_True;
}
Reference in a new issue View git blame Copy permalink