/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/

#include <precomp.h>
#include "i2s_calculator.hxx"


// NOT FULLY DEFINED SERVICES
#include <algorithm>
#include <string.h>
#include <cosv/file.hxx>
//#include <adc_manager.hxx>
//#include <adc_options.hxx>
#include <ary/qualiname.hxx>
#include <ary/idl/i_enum.hxx>
#include <ary/idl/i_exception.hxx>
#include <ary/idl/i_function.hxx>
#include <ary/idl/i_gate.hxx>
#include <ary/idl/i_interface.hxx>
#include <ary/idl/ik_interface.hxx>
#include <ary/idl/i_module.hxx>
#include <ary/idl/i_property.hxx>
#include <ary/idl/i_service.hxx>
#include <ary/idl/i_singleton.hxx>
#include <ary/idl/i_siservice.hxx>
#include <ary/idl/i_sisingleton.hxx>
#include <ary/idl/i_struct.hxx>
#include <ary/idl/i_structelem.hxx>
#include <ary/idl/i_typedef.hxx>
#include <ary/idl/ip_ce.hxx>
#include <ary/idl/ip_type.hxx>
#include <ary/namesort.hxx>
#include <nametreenode.hxx>
#include "i_nnfinder.hxx"
#include "ia_ce.hxx"
#include "ia_type.hxx"
#include "is_ce.hxx"
#include "is_type.hxx"
#include "it_ce.hxx"
#include "it_explicit.hxx"
#include "it_sequence.hxx"
#include "it_xnameroom.hxx"


namespace ary
{
namespace idl
{

template <class DEST>
DEST *
SecondariesCalculator::SearchCe4Type(Type_id i_type)
{
    Ce_id
        ce = lhf_Search_CeFromTypeId(i_type);
    if (ce.IsValid())
        return ary_cast<DEST>(& my_CeStorage()[ce]);
    return 0;
}


typedef stg::const_iterator<CodeEntity> stg_citerator;
typedef stg::iterator<CodeEntity>       stg_iterator;

typedef stg::filter_iterator<CodeEntity,Interface>
                                        interface_iterator;

typedef stg::filter_iterator<Type,ExplicitType>
                                        explicittype_iterator;

typedef ary::stg::const_filter_iterator<CodeEntity,Typedef>
                                        typedef_citerator;


inline Service *
SecondariesCalculator::lhf_SearchService( Type_id i_nType )
{
    return SearchCe4Type<Service>(i_nType);
}

inline Interface *
SecondariesCalculator::lhf_SearchInterface( Type_id i_nType )
{
    return SearchCe4Type<Interface>(i_nType);
}

inline Struct *
SecondariesCalculator::lhf_SearchStruct( Type_id i_nType )
{
    return SearchCe4Type<Struct>(i_nType);
}

inline Exception *
SecondariesCalculator::lhf_SearchException( Type_id i_nType )
{
    return SearchCe4Type<Exception>(i_nType);
}

inline const Ce_Storage &
SecondariesCalculator::my_CeStorage() const
{
    csv_assert(pCes != 0);
    return pCes->Storage();
}

inline const Type_Storage &
SecondariesCalculator::my_TypeStorage() const
{
    csv_assert(pTypes != 0);
    return pTypes->Storage();
}

inline Ce_Storage &
SecondariesCalculator::my_CeStorage()
{
    csv_assert(pCes != 0);
    return pCes->Storage();
}

inline Type_Storage &
SecondariesCalculator::my_TypeStorage()
{
    csv_assert(pTypes != 0);
    return pTypes->Storage();
}

inline void
SecondariesCalculator::insert_into2sList( CodeEntity &        o_out,
                                          int                 i_listIndex,
                                          Ce_id               i_nCe )
    { o_out.Secondaries().Access_List(i_listIndex).push_back(i_nCe); }


SecondariesCalculator::SecondariesCalculator( CeAdmin &      i_ces,
                                              TypeAdmin &    i_types )
    :   pCes(&i_ces),
        pTypes(&i_types)
{
}

SecondariesCalculator::~SecondariesCalculator()
{
}


void
SecondariesCalculator::CheckAllInterfaceBases()
{
    Module &
        rGlobalNamespace = pCes->GlobalNamespace();
    QualifiedName
        aXInterface("::com::sun::star::uno::XInterface","::");

    const Type &
        rType = pTypes->CheckIn_Type(   aXInterface,
                                        0,
                                        rGlobalNamespace.CeId(),
                                        0 );
    Type_id
        nTypeXInterface = rType.TypeId();
    const ExplicitType &
        rExplType = ary_cast<ExplicitType>(rType);
    Ce_id
        nCeXInterface = lhf_Search_CeForType(rExplType);

    interface_iterator itEnd( my_CeStorage().End() );
    for ( interface_iterator it( my_CeStorage().BeginUnreserved() );
          it != itEnd;
          ++it )
    {
        if (NOT it.IsValid())
            continue;

        Interface &
            rInterface = *it;
        if (     NOT rInterface.HasBase()               // According to UNO IDL syntax, an interface without base has com::sun::star::uno::XInterface as base.
             AND rInterface.CeId() != nCeXInterface )   // XInterface must not be base of itself.
        {
            rInterface.Add_Base(nTypeXInterface, 0);
        }
    }   // end for
}

void
SecondariesCalculator::Connect_Types2Ces()
{
    explicittype_iterator itEnd( my_TypeStorage().End() );
    for ( explicittype_iterator it( my_TypeStorage().BeginUnreserved() );
          it != itEnd;
          ++it )
    {
        if (NOT it.IsValid())
            continue;

        ExplicitType &
            rType = ary_cast<ExplicitType>(*it);
        Ce_id
            nRelatedCe = lhf_Search_CeForType(rType);
        if (nRelatedCe.IsValid())
        {
            Ce_Type *
                pNew = new Ce_Type(nRelatedCe, rType.TemplateParameters());
            my_TypeStorage().Replace_Entity( rType.TypeId(),
                                             *pNew );
        }
    }   // end for
}

void
SecondariesCalculator::Gather_CrossReferences()
{
    gather_Synonyms();

    for ( stg_iterator it = my_CeStorage().Begin();
          it != my_CeStorage().End();
          ++it )
    {
        (*it).Accept( static_cast< SPInst_asHost& >(*this) );

    }   // end for

    sort_All2s();
}

void
SecondariesCalculator::Make_Links2DeveloperManual(
                                const String &      i_devman_reffilepath )
{
//    const autodoc::Options &
//        rOptions = TheAutodocManager().TheOptions();
//
//    const String &
//        rDeveloperManual_URL
//            = rOptions.Get_Extra(autodoc::OPT_developer_guide);
//    const String
//        rDeveloperManual_ReferenceFile
//            = rOptions.Get_Extra(autodoc::OPT_developer_guide_refs_file);

//    if ( rDeveloperManual_URL.length() == 0
//         OR
//         rDeveloperManual_ReferenceFile.length() == 0 )
//    {
//        return;
//    }

    csv::File
        aFile(i_devman_reffilepath, csv::CFM_READ);
    csv::OpenCloseGuard
        aFileOpener(aFile);
    if (aFileOpener)
    {
        Read_Links2DevManual(aFile);
    }
}

namespace
{

enum E_LinkMode
{
    link2descr,
    link2ref
};

struct OrderCeIdsByName
{
                        OrderCeIdsByName(
                            const Ce_Storage &      i_storage )
                                :   rStorage(i_storage),
                                    aNameComparison() {}
    bool                operator()(
                            Ce_id                   i_ce1,
                            Ce_id                   i_ce2 ) const
    {
        return aNameComparison( rStorage[i_ce1].LocalName(),
                                rStorage[i_ce2].LocalName() );
    }

  private:
    const Ce_Storage &  rStorage;
    LesserName          aNameComparison;
};


}


void
SecondariesCalculator::do_Process( const Service & i_rData )
{
    const Service &
        rService = ary_cast<Service>(i_rData);

    // Interfaces:
    assignImplementation_toAServicesInterfaces( rService.CeId(),
												rService.CeId(),
												interface_2s_ExportingServices );
    // Services and their interfaces:
    recursive_AssignIncludingService(rService.CeId(), rService);
}

void
SecondariesCalculator::do_Process( const Interface & i_rData )
{
    assign_AsDerivedInterface( ary_cast<Interface>(i_rData) );
}

void
SecondariesCalculator::do_Process( const Struct &  i_rData )
{
    assign_AsDerivedStruct( ary_cast<Struct>(i_rData) );
}

void
SecondariesCalculator::do_Process( const Exception &  i_rData )
{
    assign_AsDerivedException( ary_cast<Exception>(i_rData) );
}

void
SecondariesCalculator::do_Process( const Typedef &  )
{
    // KORR_FUTURE
    // Find out what was meant here ???

//    const Typedef &
//        rTypedef = ary_cast<Typedef>(i_rData);
}

void
SecondariesCalculator::do_Process( const Singleton &  i_rData )
{
    const Singleton &
        rSingleton = ary_cast<Singleton>(i_rData);

    Service *
        pServ = lhf_SearchService(rSingleton.AssociatedService());
    if (pServ != 0)
    {
        insert_into2sUnique( *pServ,
							 service_2s_InstantiatingSingletons,
							 rSingleton.CeId() );
    }

    // Interfaces:
    assignImplementation_toAServicesInterfaces( rSingleton.CeId(),
												lhf_Search_CeFromTypeId(rSingleton.AssociatedService()),
												interface_2s_ExportingSingletons );
}

void
SecondariesCalculator::do_Process( const SglIfcService &  i_rData )
{
    const SglIfcService &
        rSglIfcService = ary_cast<SglIfcService>(i_rData);

    assignImplementation_toAServicesInterfaces( rSglIfcService.CeId(),
												rSglIfcService.CeId(),
												interface_2s_ExportingServices );
}

void
SecondariesCalculator::do_Process( const SglIfcSingleton &  i_rData )
{
    const SglIfcSingleton &
        rSglIfcSingleton = ary_cast<SglIfcSingleton>(i_rData);

    Type_id nBase = rSglIfcSingleton.BaseInterface();
    recursive_AssignImplementation_toExportedInterface( rSglIfcSingleton.CeId(),
														nBase,
														interface_2s_ExportingSingletons );
}

void
SecondariesCalculator::do_Process( const Function & i_rData )
{
    const Function &
        rFunction = ary_cast<Function>(i_rData);

    recursive_AssignFunction_toCeAsReturn(rFunction.CeId(), rFunction.ReturnType());

    for ( Function::ParamList::const_iterator itp = rFunction.Parameters().begin();
          itp != rFunction.Parameters().end();
          ++itp )
    {
        recursive_AssignFunction_toCeAsParameter(rFunction.CeId(), (*itp).Type());
    }   // end for (itp)

    for ( Function::ExceptionList::const_iterator itx = rFunction.Exceptions().begin();
          itx != rFunction.Exceptions().end();
          ++itx )
    {
        Exception *
            pX = lhf_SearchException(*itx);
        if (pX != 0)
        {
            insert_into2sUnique(*pX, exception_2s_RaisingFunctions, rFunction.CeId());
        }
    }   // end for (itx)
}

void
SecondariesCalculator::do_Process( const StructElement & i_rData )
{
    const StructElement &
        rStructElement = ary_cast<StructElement>(i_rData);

    recursive_AssignStructElement_toCeAsDataType(rStructElement.CeId(), rStructElement.Type());
}

void
SecondariesCalculator::do_Process( const Property & i_rData )
{
    const Property &
        rProperty = ary_cast<Property>(i_rData);

    recursive_AssignStructElement_toCeAsDataType(rProperty.CeId(), rProperty.Type());
}

Ce_id
SecondariesCalculator::lhf_Search_CeForType( const ExplicitType & i_rType ) const
{
    const ExplicitNameRoom &
        rExplicitNameRoom = ary_cast<ExplicitNameRoom>(
                                my_TypeStorage()[i_rType.NameRoom()] );
    Find_ModuleNode
        rNodeFinder( my_CeStorage(),
                     rExplicitNameRoom.NameChain_Begin(),
                     rExplicitNameRoom.NameChain_End(),
                     i_rType.Name() );

    if ( rExplicitNameRoom.IsAbsolute() )
    {
        const Module &
            rGlobalNamespace = ary_cast<Module>(
                                my_CeStorage()[predefined::ce_GlobalNamespace]);
        return Search_SubTree(  rGlobalNamespace,
                                rNodeFinder );
    }
    else
    {
        const Module &
            rStartModule = ary_cast<Module>(
                                my_CeStorage()[i_rType.ModuleOfOccurrence()]);
        Ce_id ret = Search_SubTree_UpTillRoot( rStartModule,
											   rNodeFinder );
		return ret;
    }   // endif (rExplicitNameRoom.IsAbsolute()) else
}

Ce_id
SecondariesCalculator::lhf_Search_CeFromTypeId( Type_id i_nType ) const
{
    if (NOT i_nType.IsValid())
        return Ce_id(0);
    const Ce_Type *
        pType = ary_cast<Ce_Type>( & my_TypeStorage()[i_nType] );
    return pType != 0
                ?   pType->RelatedCe()
                :   Ce_id_Null();
}

void
SecondariesCalculator::assign_CurLink( char *              i_text,
                                       const String &      i_link,
                                       const String &      i_linkUI,
                                       bool                i_isDescr,
                                       int                 i_lineCount )
{
    csv_assert(i_text != 0);

    const ary::idl::Module *
        pModule = & ary_cast<Module>(
                        my_CeStorage()[predefined::ce_GlobalNamespace]);

    char * pPastNext = 0;
    char * pNext = i_text;
    for ( ;
          (pPastNext = strstr(pNext,".")) != 0;
          pNext = pPastNext + 1 )
    {
        String sNext(pNext, pPastNext-pNext);
        Ce_id nModule = pModule->Search_Name(sNext);
        if (nModule.IsValid())
        {
            pModule = ary_cast<Module>( & my_CeStorage()[nModule] );
        }
        else
        {
            pModule = 0;
        }

        if (pModule == 0)
        {
            Cerr() << "Warning: Invalid line nr. "
                   << i_lineCount
                   << " in DevelopersGuide reference file:\n"
                   << reinterpret_cast< const char* >(i_text)
                   << "\n"
                   << Endl();
            return;
        }
    }   // end for

    pPastNext = strchr(pNext,':');
    bool bMember = pPastNext != 0;
    String sCe( pNext, (bMember ? csv::str::size(pPastNext-pNext) : csv::str::maxsize) );

//  KORR_FUTURE
//  String sMember(bMember ? pPastNext+1, "");

    Ce_id nCe = pModule->Search_Name(sCe);
    if (NOT nCe.IsValid())
    {
        Cerr() << "Warning: Invalid line nr. "
               << i_lineCount
               << " in DevelopersGuide reference file:\n"
               << reinterpret_cast< const char* >(i_text)
               << "\n"
               << Endl();
        return;
    }

    CodeEntity &
        rCe = my_CeStorage()[nCe];
    if (NOT bMember)
    {
        if (i_isDescr)
            rCe.Secondaries().Add_Link2DescriptionInManual(i_link, i_linkUI);
        else
            rCe.Secondaries().Add_Link2RefInManual(i_link, i_linkUI);
        return;
    }
    else
    {
    // KORR_FUTURE
    //   Provisorial just doing nothing (or may be
    //   adding a link at main Ces lists).
//    if (i_isDescr)
//        rCe.Secondaries().Add_Link2DescriptionInManual(i_link);
//    else
//        rCe.Secondaries().Add_Link2RefInManual(i_link);
    }
}

void
SecondariesCalculator::gather_Synonyms()
{
    const Ce_Storage &
        cstrg = my_CeStorage();
    typedef_citerator itEnd(cstrg.End());
    for ( typedef_citerator it(cstrg.Begin());
          it != itEnd;
          ++it )
    {
        if (NOT it.IsValid())
            continue;

        const Typedef &
            rTypedef = *it;
        recursive_AssignAsSynonym(rTypedef.CeId(), rTypedef);
    }   // end for (itTd)
}

void
SecondariesCalculator::recursive_AssignAsSynonym( Ce_id               i_synonymousTypedefsId,
                                                  const Typedef &     i_TypedefToCheck )
{
    Ce_id
        nCe = lhf_Search_CeFromTypeId(i_TypedefToCheck.DefiningType());
    if (NOT nCe.IsValid())
        return;
    CodeEntity &
        rCe = my_CeStorage()[nCe];

    switch (rCe.AryClass())  // KORR_FUTURE: make this faster, remove switch.
    {
        case Interface::class_id:
                    insert_into2sList( rCe,
									   interface_2s_SynonymTypedefs,
									   i_synonymousTypedefsId );
                    break;
        case Struct::class_id:
                    insert_into2sList( rCe,
									   struct_2s_SynonymTypedefs,
									   i_synonymousTypedefsId );
                    break;
        case Enum::class_id:
                    insert_into2sList( rCe,
									   enum_2s_SynonymTypedefs,
									   i_synonymousTypedefsId );
                    break;
        case Typedef::class_id:
                    insert_into2sList( rCe,
									   typedef_2s_SynonymTypedefs,
									   i_synonymousTypedefsId );
                    recursive_AssignAsSynonym( i_synonymousTypedefsId,
                                               static_cast< Typedef& >(rCe) );
                    break;
                // default: do nothing.
    }
}

void
SecondariesCalculator::recursive_AssignIncludingService( Ce_id               i_includingServicesId,
                                                         const Service &     i_ServiceToCheckItsIncludes )
{
    Dyn_StdConstIterator<CommentedRelation>
        pIncludedServices;
    i_ServiceToCheckItsIncludes.Get_IncludedServices(pIncludedServices);

    for ( StdConstIterator<CommentedRelation> &
                itServ = *pIncludedServices;
          itServ;
          ++itServ )
    {
        Service *
            pServ = lhf_SearchService((*itServ).Type());
        if (pServ != 0)
        {
            insert_into2sUnique( *pServ,
								 service_2s_IncludingServices,
								 i_includingServicesId
							   );
            recursive_AssignIncludingService(i_includingServicesId, *pServ);

        }   // end if

        assignImplementation_toAServicesInterfaces( i_includingServicesId,
													lhf_Search_CeFromTypeId( (*itServ).Type() ),
													interface_2s_ExportingServices );
    }   // end for
}

void
SecondariesCalculator::assign_AsDerivedInterface( const Interface & i_rDerived )
{
    ary::Dyn_StdConstIterator<ary::idl::CommentedRelation>
        pHelp;
    ary::idl::ifc_interface::attr::Get_Bases(pHelp, i_rDerived);

    for ( ary::StdConstIterator<ary::idl::CommentedRelation> & it = *pHelp;
          it.operator bool();
          ++it )
    {
        Interface *
            pIfc = lhf_SearchInterface( (*it).Type() );
        if (pIfc == 0)
            continue;

        insert_into2sList( *pIfc,
                           interface_2s_Derivations,
						   i_rDerived.CeId() );
    }   // end for
}

void
SecondariesCalculator::assign_AsDerivedStruct( const Struct &   i_rDerived )
{
    Type_id
        nBase = i_rDerived.Base();
    if (nBase.IsValid())
    {
        Struct *
            pParent = lhf_SearchStruct(nBase);
        if (pParent != 0)
        {
            insert_into2sList( *pParent,
							   struct_2s_Derivations,
							   i_rDerived.CeId() );
        }
    }
}

void
SecondariesCalculator::assign_AsDerivedException( const Exception &   i_rDerived )
{
    Type_id
        nBase = i_rDerived.Base();
    if (nBase.IsValid())
    {
        Exception *
            pParent = lhf_SearchException(nBase);
        if (pParent != 0)
        {
            insert_into2sList( *pParent,
							   exception_2s_Derivations,
							   i_rDerived.CeId() );
        }   // end if
    }   // end if
}

void
SecondariesCalculator::assignImplementation_toAServicesInterfaces(
                                                    Ce_id               i_nImpl,
                                                    Ce_id               i_nService,
                                                    E_2s_of_Interface   i_eList )
{
    if (NOT i_nService.IsValid())
        return;
    Service *
        pService = ary_cast<Service>( & my_CeStorage()[i_nService] );
    SglIfcService *
        pSglIfcService = ary_cast<SglIfcService>( & my_CeStorage()[i_nService] );

    if (pService != 0)
    {
        Dyn_StdConstIterator<CommentedRelation>
            pSupportedInterfaces;
        pService->Get_SupportedInterfaces(pSupportedInterfaces);

        for ( StdConstIterator<CommentedRelation> &
                    itInfc = *pSupportedInterfaces;
              itInfc.operator bool();
			  ++itInfc )
        {
            recursive_AssignImplementation_toExportedInterface( i_nImpl,
																(*itInfc).Type(),
																i_eList );
        }   // end for
    }
    else if (pSglIfcService != 0)
    {
        Type_id nBase = pSglIfcService->BaseInterface();
        recursive_AssignImplementation_toExportedInterface( i_nImpl,
															nBase,
															i_eList );
    }   // end if
}

void
SecondariesCalculator::recursive_AssignImplementation_toExportedInterface(
                                                    Ce_id               i_nService,
													Type_id             i_nExportedInterface,
													E_2s_of_Interface   i_eList )
{
    Interface *
        pIfc = lhf_SearchInterface(i_nExportedInterface);
    if (pIfc == 0)
        return;

    insert_into2sUnique( *pIfc,
						 i_eList,
						 i_nService );
    Dyn_StdConstIterator<CommentedRelation>
        pBases;
    ary::idl::ifc_interface::attr::Get_Bases(pBases, *pIfc);
    for ( StdConstIterator<CommentedRelation> & it = *pBases;
          it.operator bool();
          ++it )
    {
        recursive_AssignImplementation_toExportedInterface(i_nService, (*it).Type(), i_eList);
    }
}

void
SecondariesCalculator::recursive_AssignFunction_toCeAsReturn( Ce_id         i_nFunction,
                                                              Type_id       i_nReturnType )
{
    Ce_id
        nCe = lhf_Search_CeFromTypeId(i_nReturnType);
    if (NOT nCe.IsValid())
        return;

    CodeEntity &
        rCe = my_CeStorage()[nCe];
    switch (rCe.AryClass())  // KORR_FUTURE: make this faster, remove switch.
    {
        case Interface::class_id:
                    insert_into2sList( rCe,
									   interface_2s_AsReturns,
									   i_nFunction );
                    break;
        case Struct::class_id:
                    insert_into2sList( rCe,
									   struct_2s_AsReturns,
									   i_nFunction );
                    break;
        case Enum::class_id:
                    insert_into2sList( rCe,
									   enum_2s_AsReturns,
									   i_nFunction );
                    break;
        case Typedef::class_id:
                    insert_into2sList( rCe,
									   typedef_2s_AsReturns,
									   i_nFunction );
                    recursive_AssignFunction_toCeAsReturn( i_nFunction,
                                                           static_cast< Typedef& >(rCe).DefiningType() );
                    break;
        // default: do nothing.
    }
}

void
SecondariesCalculator::recursive_AssignFunction_toCeAsParameter( Ce_id      i_nFunction,
                                                                 Type_id    i_nParameterType )
{
    Ce_id
        nCe = lhf_Search_CeFromTypeId(i_nParameterType);
    if (NOT nCe.IsValid())
        return;

    CodeEntity &
        rCe = my_CeStorage()[nCe];
    switch (rCe.AryClass())  // KORR_FUTURE: make this faster, remove switch.
    {
        case Interface::class_id:
                    insert_into2sList( rCe,
									   interface_2s_AsParameters,
									   i_nFunction );
                    break;
        case Struct::class_id:
                    insert_into2sList( rCe,
									   struct_2s_AsParameters,
									   i_nFunction );
                    break;
        case Enum::class_id:
                    insert_into2sList( rCe,
									   enum_2s_AsParameters,
									   i_nFunction );
                    break;
        case Typedef::class_id:
                    insert_into2sList( rCe,
									   typedef_2s_AsParameters,
									   i_nFunction );
                    recursive_AssignFunction_toCeAsParameter( i_nFunction,
                                                              static_cast< Typedef& >(rCe).DefiningType() );
                    break;
        // default: do nothing.
    }
}

void
SecondariesCalculator::recursive_AssignStructElement_toCeAsDataType( Ce_id   i_nDataElement,
                                                                     Type_id i_nDataType )
{
    Ce_id
        nCe = lhf_Search_CeFromTypeId(i_nDataType);
    if (NOT nCe.IsValid())
        return;

    CodeEntity &
        rCe = my_CeStorage()[nCe];
    switch (rCe.AryClass())  // KORR_FUTURE: make this faster, remove switch.
    {
        case Interface::class_id:
                    insert_into2sList( rCe,
									   interface_2s_AsDataTypes,
									   i_nDataElement );
                    break;
        case Struct::class_id:
                    insert_into2sList( rCe,
									   struct_2s_AsDataTypes,
									   i_nDataElement );
                    break;
        case Enum::class_id:
                    insert_into2sList( rCe,
									   enum_2s_AsDataTypes,
									   i_nDataElement );
                    break;
        case Typedef::class_id:
                    insert_into2sList( rCe,
									   typedef_2s_AsDataTypes,
									   i_nDataElement );
                    recursive_AssignFunction_toCeAsParameter( i_nDataElement,
                                                              static_cast< Typedef& >(rCe).DefiningType() );
                    break;
        // default: do nothing.
    }   // end switch
}

void
SecondariesCalculator::insert_into2sUnique( CodeEntity &        o_out,
											int                 i_listIndex,
											Ce_id               i_nCe )
{
    std::vector<Ce_id> &
        rOut = o_out.Secondaries().Access_List(i_listIndex);
    if (std::find(rOut.begin(),rOut.end(),i_nCe) != rOut.end())
        return;
    rOut.push_back(i_nCe);
}

void
SecondariesCalculator::sort_All2s()
{
    OrderCeIdsByName
        aIdOrdering(my_CeStorage());

    for ( stg_iterator it = my_CeStorage().Begin();
          it != my_CeStorage().End();
          ++it )
    {
        Ce_2s &
            r2s = (*it).Secondaries();
        int iCount = r2s.CountXrefLists();
        for (int i = 0; i < iCount; ++i)
        {
            std::sort( r2s.Access_List(i).begin(),
                       r2s.Access_List(i).end(),
                       aIdOrdering );
        }   // end for (i)
    }   // end for (it)
}

void
SecondariesCalculator::Read_Links2DevManual( csv::bstream & i_file )
{
    StreamLock  aLine(300);
    StreamStr & rLine = aLine();


    String      sCurLink;
    String      sCurLinkUI;
    E_LinkMode  eCurMode = link2ref;

	int lineCount = 0;
    const char * sLink = "LINK:";
    const char * sDescr = "DESCR:";
    const char * sTopic = "TOPIC:";
    const char * sRef = "REF:";
    const UINT8  cMaxASCIINumWhiteSpace = 32;

    while (NOT i_file.eod())
    {
		++lineCount;

        rLine.reset();
        rLine.operator_read_line(i_file);

        if ( *rLine.c_str() >= 'a' )
        {
            assign_CurLink(rLine.begin(), sCurLink, sCurLinkUI, eCurMode == link2descr, lineCount);
        }
        else if ( strncmp(rLine.c_str(), sLink, strlen(sLink)) == 0 )
        {
            sCurLink = rLine.c_str()+5;
            sCurLinkUI.clear();
        }
        else if ( strncmp(rLine.c_str(), sDescr, strlen(sDescr)) == 0 )
        {
            sCurLinkUI = rLine.c_str()+6;
        }
        else if ( strncmp(rLine.c_str(), sTopic, strlen(sTopic)) == 0 )
        {
            eCurMode = link2descr;
        }
        else if ( strncmp(rLine.c_str(), sRef, strlen(sRef)) == 0 )
        {
            eCurMode = link2ref;
        }
        else if (static_cast<UINT8>(*rLine.c_str()) > cMaxASCIINumWhiteSpace)
        {
            assign_CurLink(rLine.begin(), sCurLink, sCurLinkUI, eCurMode == link2descr, lineCount);
        }
     // else
        //  Ignore empty line.

    }   // end while
}


}   // namespace idl
}   // namespace ary