source: dev/BasicCompiler_Common/include/Namespace.h@ 107

#pragma once

#include <vector>
#include <string>
#include <boost/foreach.hpp>

using namespace std;

class NamespaceScopes : public vector<string>
{
public:
    NamespaceScopes(){}
    NamespaceScopes( const string &namespaceStr );
    ~NamespaceScopes(){}

    string ToString() const
    {
        string namespaceStr;
        const vector<string> &me = *this;

        bool isFirst = true;
        BOOST_FOREACH( const string &itemStr, me ){
            if( isFirst ){
                isFirst = false;
            }
            else{
                namespaceStr += ".";
            }

            namespaceStr += itemStr;
        }
        return namespaceStr;
    }

    // 等しいかをチェック
    bool IsEqual( const string &name ) const
    {
        if( ToString() == name ){
            return true;
        }
        return false;
    }

    // 等しいかをチェック
    bool IsEqual( const NamespaceScopes &namespaceScopes ) const
    {
        if( ToString() == namespaceScopes.ToString() ){
            return true;
        }
        return false;
    }

    // 所属しているかをチェック
    // 例:
    // baseNamespaceScopes =  "Discoversoft"
    // entryNamespaceScopes = "Discoversoft.ActiveBasic"
    // この場合、entryNamespaceScopes は baseNamespaceScopes に所属している。
    static bool IsBelong( const NamespaceScopes &baseNamespaceScopes, const NamespaceScopes &entryNamespaceScopes )
    {
        if( baseNamespaceScopes.size() > entryNamespaceScopes.size() ){
            return false;
        }

        for( int i=0; i<(int)baseNamespaceScopes.size(); i++ ){
            if( baseNamespaceScopes[i] != entryNamespaceScopes[i] ){
                return false;
            }
        }
        return true;
    }

    bool IsImported() const;

    bool IsLiving() const;

    // 包括しているかをチェック
    // 例:
    // this =   "Discoversoft.ActiveBasic"
    // living = "Discoversoft.ActiveBasic"
    // name =   "ActiveBasic"
    // この場合、living は name を包括している。
    bool IsCoverd( const string &name ) const;
    bool IsCoverd( const NamespaceScopes &namespaceScopes ) const;

    // 指定された名前空間が同一エリアと見なされるかどうかをチェック
    static bool IsSameArea( const NamespaceScopes &baseNamespaceScopes, const NamespaceScopes &entryNamespaceScopes ){
        if( entryNamespaceScopes.size() ){
            if( baseNamespaceScopes.IsCoverd( entryNamespaceScopes ) ){
                // 包括しているときは同一と見なす
                return true;
            }
        }
        else{
            if( baseNamespaceScopes.size() ){
                // 名前空間の判断が必要なとき
                if( baseNamespaceScopes.IsImported()
                    || baseNamespaceScopes.IsLiving() ){
                    // Using指定があるとき
                    // または
                    // 指定された名前空間が現在の名前空間スコープと同一のとき
                    return true;
                }
            }
            else{
                return true;
            }
        }

        return false;
    }
};

class NamespaceScopesCollection : public vector<NamespaceScopes>
{
public:
    bool IsExist( const NamespaceScopes &namespaceScopes ) const
    {
        const NamespaceScopesCollection &namespaceScopesCollection = *this;
        BOOST_FOREACH( const NamespaceScopes &tempNamespaceScopes, namespaceScopesCollection ){
            if( tempNamespaceScopes.IsEqual( namespaceScopes ) ){
                return true;
            }
        }
        return false;
    }
    bool IsExist( const string &namespaceStr ) const
    {
        return IsExist( NamespaceScopes( namespaceStr ) );
    }
    void SplitNamespace( const char *fullName, char *namespaceStr, char *simpleName ) const;

    void Imports( const string &namespaceStr );

    static bool CollectNamespaces( const char *source, NamespaceScopesCollection &namespaceScopesCollection );
};