xref: /trunk/main/autodoc/source/ary/idl/ia_ce.cxx (revision d291ea287686f95dc2fff9ad28612d818a1c6b1e)

/**************************************************************
 *
 * 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 "ia_ce.hxx"


// NOT FULLY DEFINED SERVICES
#include <algorithm>
#include <cosv/tpl/tpltools.hxx>
#include <ary/idl/i_attribute.hxx>
#include <ary/idl/i_constant.hxx>
#include <ary/idl/i_constgroup.hxx>
#include <ary/idl/i_enum.hxx>
#include <ary/idl/i_enumvalue.hxx>
#include <ary/idl/i_exception.hxx>
#include <ary/idl/i_function.hxx>
#include <ary/idl/i_interface.hxx>
#include <ary/idl/i_module.hxx>
#include <ary/idl/i_namelookup.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_traits.hxx>
#include <ary/idl/i_typedef.hxx>
#include <idsort.hxx>
#include "ia_type.hxx"
#include "is_ce.hxx"
#include "it_tplparam.hxx"




namespace ary
{
namespace idl
{

inline Module &
CeAdmin::lhf_Access_Module( Ce_id i_nId )
    { return ary_cast<Module>(Storage()[i_nId]); }

inline void
CeAdmin::lhf_Put2Storage_and_AssignId( CodeEntity & pass_io_rCe )
    { // This also assigns an ID to pass_io_rCe:
      Storage().Store_Entity(pass_io_rCe);
      my_NameDictionary().Add_Name( pass_io_rCe.LocalName(),
                                    pass_io_rCe.CeId(),
                                    pass_io_rCe.AryClass(),
                                    pass_io_rCe.Owner() );
    }

inline void
CeAdmin::lhf_Store_NewEntity( DYN CodeEntity &  pass_io_rCe,
                                   Module &          i_rOwner )
{
    lhf_Put2Storage_and_AssignId(pass_io_rCe);
    i_rOwner.Add_Name(pass_io_rCe.LocalName(), pass_io_rCe.CeId());
}

inline void
CeAdmin::lhf_Store_NewEntity( DYN CodeEntity &  pass_io_rCe,
                                   Ce_id             i_nOwnerModule )
{
    lhf_Store_NewEntity(pass_io_rCe, lhf_Access_Module(i_nOwnerModule));
}



CeAdmin::CeAdmin( NameLookup &        io_rNameDictionary,
                  TypeAdmin &         io_rTypePilot )
    :   pStorage(new Ce_Storage),
        pGlobalNamespace(0),
        pNameDictionary(&io_rNameDictionary),
        pTypePilot(&io_rTypePilot)
{
    Storage().Set_Reserved(
                    predefined::ce_GlobalNamespace,
                    *new Module );
    pGlobalNamespace = &lhf_Access_Module(Ce_id(predefined::ce_GlobalNamespace));
}

CeAdmin::~CeAdmin()
{
}



Module &
CeAdmin::CheckIn_Module( Ce_id               i_nParentId,
                            const String &      i_sName )
{
    Module & rOwner  = lhf_Access_Module(i_nParentId);
    Ce_id    nId     = rOwner.Search_Name(i_sName);
    if (nId.IsValid())
    {
        return lhf_Access_Module(nId);
    }

    Module & ret = *new Module( i_sName,
                                rOwner );
    lhf_Store_NewEntity(ret, rOwner);
    return ret;
}

Service &
CeAdmin::Store_Service( Ce_id           i_nOwner,
                        const String &  i_sName )
{
    Service & ret = *new Service( i_sName,
                                  i_nOwner );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

SglIfcService &
CeAdmin::Store_SglIfcService( Ce_id               i_nOwner,
                                   const String &      i_sName,
                                   Type_id             i_nBaseInterface )
{
    SglIfcService &
        ret = *new SglIfcService( i_sName,
                                  i_nOwner,
                                  i_nBaseInterface );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

Interface &
CeAdmin::Store_Interface( Ce_id               i_nOwner,
                                  const String &      i_sName,
                                  Type_id             i_nBase )
{
    Interface & ret = *new Interface( i_sName,
                                      i_nOwner );
    lhf_Store_NewEntity(ret, i_nOwner);
    if (i_nBase.IsValid())
        ret.Add_Base(i_nBase, 0);
    return ret;
}

Struct &
CeAdmin::Store_Struct( Ce_id               i_nOwner,
                               const String &      i_sName,
                               Type_id             i_nBase,
                               const String &      i_sTemplateParam )
{
    if (NOT i_sTemplateParam.empty())
    {
        return lhf_Store_TplStruct( i_nOwner,
                                    i_sName,
                                    i_nBase,
                                    i_sTemplateParam );
    }

    Struct & ret = *new Struct( i_sName,
                                i_nOwner,
                                i_nBase,
                                String::Null_(),
                                Type_id::Null_() );
    lhf_Store_NewEntity(ret, i_nOwner);

    return ret;
}

Exception &
CeAdmin::Store_Exception( Ce_id               i_nOwner,
                                  const String &      i_sName,
                                  Type_id             i_nBase )
{
    Exception & ret = *new Exception( i_sName,
                                      i_nOwner,
                                      i_nBase );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

Enum &
CeAdmin::Store_Enum( Ce_id               i_nOwner,
                             const String &      i_sName )
{
    Enum & ret = *new Enum( i_sName,
                            i_nOwner );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

Typedef &
CeAdmin::Store_Typedef( Ce_id               i_nOwner,
                                const String &      i_sName,
                                Type_id             i_nDefiningType )
{
    Typedef & ret = *new Typedef( i_sName,
                                  i_nOwner,
                                  i_nDefiningType );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}


ConstantsGroup &
CeAdmin::Store_ConstantsGroup( Ce_id               i_nOwner,
                                       const String &      i_sName )
{
    ConstantsGroup & ret = *new ConstantsGroup( i_sName,
                                                i_nOwner );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

Singleton &
CeAdmin::Store_Singleton( Ce_id               i_nOwner,
                                  const String &      i_sName )
{
    Singleton & ret = *new Singleton( i_sName,
                                      i_nOwner );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

SglIfcSingleton &
CeAdmin::Store_SglIfcSingleton( Ce_id               i_nOwner,
                                     const String &      i_sName,
                                     Type_id             i_nBaseInterface )
{
    SglIfcSingleton &
        ret = *new SglIfcSingleton( i_sName,
                                    i_nOwner,
                                    i_nBaseInterface );
    lhf_Store_NewEntity(ret, i_nOwner);
    return ret;
}

Constant &
CeAdmin::Store_Constant( Ce_id               i_nOwner,
                                 const String &      i_sName,
                                 Type_id             i_nType,
                                 const String &      i_sValue )
{
    ConstantsGroup &
        rOwner  = ary_cast<ConstantsGroup>(Storage()[i_nOwner]);
    Constant & ret = *new Constant( i_sName,
                                    i_nOwner,
                                    rOwner.NameRoom(),
                                    i_nType,
                                    i_sValue );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Constant(ret.CeId());
    return ret;
}

Property &
CeAdmin::Store_Property( Ce_id                  i_nOwner,
                                 const String &         i_sName,
                                 Type_id                i_nType,
                                 Property::Stereotypes  i_stereotypes )
{
    Service &
        rOwner = ary_cast<Service>(Storage()[i_nOwner]);
    Property & ret = *new Property( i_sName,
                                    i_nOwner,
                                    rOwner.NameRoom(),
                                    i_nType,
                                    i_stereotypes );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Property(ret.CeId());
    return ret;
}

Function &
CeAdmin::Store_Function( Ce_id               i_nOwner,
                                 const String &      i_sName,
                                 Type_id             i_nReturnType,
                                 bool                i_bOneWay )
{
    Interface &
        rOwner = ary_cast<Interface>(Storage()[i_nOwner]);
    Function & ret = *new Function( i_sName,
                                    i_nOwner,
                                    rOwner.NameRoom(),
                                    i_nReturnType,
                                    i_bOneWay);
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Function(ret.CeId());
    return ret;
}

Function &
CeAdmin::Store_ServiceConstructor( Ce_id               i_nOwner,
                                        const String &      i_sName )
{
    SglIfcService &
                rOwner = ary_cast<SglIfcService>(Storage()[i_nOwner]);
    Function &  ret = *new Function( i_sName,
                                     i_nOwner,
                                     rOwner.NameRoom() );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Constructor(ret.CeId());
    return ret;
}

StructElement &
CeAdmin::Store_StructMember( Ce_id               i_nOwner,
                                     const String &      i_sName,
                                     Type_id             i_nType )
{
    Struct &
        rOwner = ary_cast<Struct>(Storage()[i_nOwner]);
    StructElement & ret = *new StructElement( i_sName,
                                              i_nOwner,
                                              rOwner.NameRoom(),
                                              i_nType );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Member(ret.CeId());
    return ret;
}

StructElement &
CeAdmin::Store_ExceptionMember( Ce_id               i_nOwner,
                                        const String &      i_sName,
                                        Type_id             i_nType )
{
    Exception &
        rOwner = ary_cast<Exception>(Storage()[i_nOwner]);
    StructElement & ret = *new StructElement( i_sName,
                                              i_nOwner,
                                              rOwner.NameRoom(),
                                              i_nType );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Member(ret.CeId());
    return ret;
}

EnumValue &
CeAdmin::Store_EnumValue( Ce_id               i_nOwner,
                                  const String &      i_sName,
                                  const String &      i_sValue )
{
    Enum &
        rOwner = ary_cast<Enum>(Storage()[i_nOwner]);
    EnumValue & ret = *new EnumValue( i_sName,
                                      i_nOwner,
                                      rOwner.NameRoom(),
                                      i_sValue );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Value(ret.CeId());
    return ret;
}

Attribute &
CeAdmin::Store_Attribute( Ce_id               i_nOwner,
                                  const String &      i_sName,
                                  Type_id             i_nType,
                                  bool                i_bReadOnly,
                                  bool                i_bBound )
{
    Interface &
        rOwner = ary_cast<Interface>(Storage()[i_nOwner]);

    Attribute & ret = *new Attribute ( i_sName,
                                       i_nOwner,
                                       rOwner.NameRoom(),
                                       i_nType,
                                       i_bReadOnly,
                                       i_bBound );
    lhf_Put2Storage_and_AssignId(ret);
    rOwner.Add_Attribute(ret.CeId());
    return ret;
}

const Module &
CeAdmin::GlobalNamespace() const
{
    csv_assert(pGlobalNamespace);
    return *pGlobalNamespace;
}

const CodeEntity &
CeAdmin::Find_Ce( Ce_id i_nId ) const
{
    return Storage()[i_nId];

}

const Module &
CeAdmin::Find_Module( Ce_id i_nId ) const
{
    return ary_cast<Module>(Storage()[i_nId]);
}

const Module *
CeAdmin::Search_Module( Ce_id i_nId ) const
{
    if (NOT i_nId.IsValid())
        return 0;
    return ary_cast<Module>( & Storage()[i_nId] );
}

const Function &
CeAdmin::Find_Function( Ce_id i_nId ) const
{
    return ary_cast<Function>(Storage()[i_nId]);
}

const Property &
CeAdmin::Find_Property( Ce_id i_nId ) const
{
    return ary_cast<Property>(Storage()[i_nId]);
}

const EnumValue &
CeAdmin::Find_EnumValue( Ce_id i_nId ) const
{
    return ary_cast<EnumValue>(Storage()[i_nId]);
}

const Constant &
CeAdmin::Find_Constant( Ce_id i_nId ) const
{
    return ary_cast<Constant>(Storage()[i_nId]);
}

const StructElement &
CeAdmin::Find_StructElement( Ce_id i_nId ) const
{
    return ary_cast<StructElement>(Storage()[i_nId]);
}

void
CeAdmin::Get_Text( StringVector &      o_module,
                            String &            o_ce,
                            String &            o_member,
                            const CodeEntity &  i_ce ) const
{
    const CodeEntity * pCe = &i_ce;
    csv::erase_container(o_module);
    o_ce.clear();
    o_member.clear();

    switch ( pCe->SightLevel() )
    {
        // Here are intentionally no breaks!
        case sl_Member:
                        if ( is_type<Function>(*pCe) )
                            o_member = StreamLock(200)()
                                            << pCe->LocalName()
                                            << "()"
                                            << c_str;
                        else
                            o_member = pCe->LocalName();
                        pCe = & Storage()[pCe->Owner()];
        case sl_File:
                        o_ce = pCe->LocalName();
                        pCe = & Storage()[pCe->NameRoom()];
        case sl_Module:
                        get_ModuleText(o_module,*pCe);
                        break;
        default:
                        csv_assert(false);
    }   // end switch
}

const NameLookup &
CeAdmin::NameDictionary() const
{
    return *pNameDictionary;
}


void
CeAdmin::Get_AlphabeticalIndex( std::vector<Ce_id> &            o_rResult,
                                alphabetical_index::E_Letter    i_cLetter ) const
{
    const int C_nLowerUpperDiff = 'a'-'A';

    // Establishing filter:
    UINT8 filter[256];

    UINT8 nLetter = static_cast<UINT8>(i_cLetter);
    memset(filter, 0, 256);
    filter[nLetter] = 1;
    if ( i_cLetter != alphabetical_index::non_alpha )
        filter[nLetter - C_nLowerUpperDiff] = 1;

    // Gather entities which start with i_cLetter:
    o_rResult.reserve(1000);
    idl::Ce_Storage::c_iter
        itEnd = Storage().End();
    for ( idl::Ce_Storage::c_iter it = Storage().BeginUnreserved();
          it != itEnd;
          ++it )
    {
        if ( filter[ static_cast<UINT8>(*(*it).LocalName().c_str()) ] == 1 )
            o_rResult.push_back( (*it).CeId() );
    }

    std::sort( o_rResult.begin(),
               o_rResult.end(),
               IdSorter<Ce_Compare>() );
}


Module &
CeAdmin::GlobalNamespace()
{
    csv_assert(pGlobalNamespace);
    return *pGlobalNamespace;
}

CodeEntity &
CeAdmin::Find_Ce( Ce_id i_nId )
{
    return Storage()[i_nId];
}

void
CeAdmin::get_ModuleText( StringVector &      o_module,
                              const CodeEntity &  i_ce ) const
{
    if (i_ce.NameRoom().IsValid())
    {
        const CodeEntity &
            rParent = Storage()[i_ce.NameRoom()];
        get_ModuleText(o_module, rParent);
        o_module.push_back(i_ce.LocalName());
    }
}

Struct &
CeAdmin::lhf_Store_TplStruct( Ce_id               i_nOwner,
                                   const String &      i_sName,
                                   Type_id             i_nBase,
                                   const String &      i_sTemplateParam )
{
    csv_assert(NOT i_sTemplateParam.empty());

    TemplateParamType &
        rTpt = pTypePilot->Store_TemplateParamType(i_sTemplateParam);

    Struct & ret = *new Struct( i_sName,
                                i_nOwner,
                                i_nBase,
                                i_sTemplateParam,
                                rTpt.TypeId() );
    lhf_Store_NewEntity(ret, i_nOwner);
    rTpt.Set_StructId(ret.CeId());

    return ret;
}


}   // namespace idl
}   // namespace ary