examples/SysLibs/ECom/InterfaceDefinition/ExampleResolver.cpp

/*
Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:  
*/



#include <ecom.h>
#include <ecomerrorcodes.h>
#include <ecomresolverparams.h>
#include <implementationinformation.h>
#include <publicregistry.h>

#include "ExampleResolver.h"

CExampleResolver* CExampleResolver::NewL(MPublicRegistry& aRegistry)
        {
        return new(ELeave) CExampleResolver(aRegistry);
        }

CExampleResolver::~CExampleResolver()
        {
        if(iImplementationInfoArray)
                {
                iImplementationInfoArray->Reset();
                delete iImplementationInfoArray;
                }
        }

CExampleResolver::CExampleResolver(MPublicRegistry& aRegistry)
: CResolver(aRegistry)
        {
        // Do nothing here
        }

TUid CExampleResolver::IdentifyImplementationL(TUid aInterfaceUid, 
        const TEComResolverParams& aAdditionalParameters) const
        {
        RImplInfoArray& implementationsInfo = iRegistry.ListImplementationsL(aInterfaceUid);
        TUid found = KNullUid;
        if(implementationsInfo.Count())
                {
                found = Resolve(implementationsInfo, aAdditionalParameters);
                }
        return found;
        }

TUid CExampleResolver::Resolve(const RImplInfoArray& aImplementationsInfo, 
        const TEComResolverParams& aAdditionalParameters) const
        {
        // Loop through the implementations matching on type
        const TInt count = aImplementationsInfo.Count();
        for(TInt index = 0; index < count; ++index)
                {
                const CImplementationInformation& impData = *aImplementationsInfo[index];
                // As soon as we get a match on the datatype then return uid of the 
                // implementation found.
                if (Match(impData.DataType(),                                           // The Datatype of this implementation
                                  aAdditionalParameters.DataType(),                     // The type we are trying to find
                                  aAdditionalParameters.IsWildcardMatch()))     // If wildcards should be used
                        return impData.ImplementationUid();
                }

        return KNullUid;
        }

RImplInfoArray* CExampleResolver::ListAllL(TUid aInterfaceUid, 
        const TEComResolverParams& aAdditionalParameters) const
        {
        // Use the member var to create the array so that we get proper cleanup behaviour
        iImplementationInfoArray = new(ELeave) RImplInfoArray;
        RImplInfoArray* retList = iImplementationInfoArray;

        RImplInfoArray& fullList = iRegistry.ListImplementationsL(aInterfaceUid);

        const TBool useWildcards = aAdditionalParameters.IsWildcardMatch();
        const TDesC8& matchType = aAdditionalParameters.DataType();
        const TInt numImps = fullList.Count();
        for(TInt index = 0; index < numImps; ++index)
                {
                if(Match(fullList[index]->DataType(), matchType, useWildcards))
                        {
                        User::LeaveIfError(retList->Append(fullList[index]));
                        }
                }

        // Reset the member variable because we are passing ownership back
        iImplementationInfoArray = NULL;
        return retList;
        }

TBool CExampleResolver::Match(const TDesC8& aImplementationType, 
        const TDesC8& aMatchType, 
        TBool aUseWildcards) const
        {
        TInt matchPos = KErrNotFound;

        _LIT8(dataSeparator, "||");
        const TInt separatorLength = dataSeparator().Length();

        // Look for the section separator marker '||'
        TInt separatorPos = aImplementationType.Find(dataSeparator);
        if(separatorPos == KErrNotFound)
                {
                // Match against the whole string
                if(aUseWildcards)
                        matchPos = aImplementationType.Match(aMatchType);
                else
                        matchPos = aImplementationType.Compare(aMatchType);
                }
        else
                {
                // Find the first section, up to the separator
                TPtrC8 dataSection = aImplementationType.Left(separatorPos);
                TPtrC8 remainingData = aImplementationType.Mid(separatorPos + separatorLength);
                // Match against each section in turn
                while(separatorPos != KErrNotFound)
                        {
                        // Search this section
                        if(aUseWildcards)
                                matchPos = dataSection.Match(aMatchType);
                        else
                                matchPos = dataSection.Compare(aMatchType);

                        // If we found it then no need to continue, so return
                        if(matchPos != KErrNotFound)
                                return ETrue;

                        // Move on to the next section
                        separatorPos = remainingData.Find(dataSeparator);
                        if(separatorPos != KErrNotFound)
                                {
                                dataSection.Set(remainingData.Left(separatorPos));
                                remainingData.Set(remainingData.Mid(separatorPos + separatorLength));
                                }
                        else
                                dataSection.Set(remainingData);
                        }

                // Check the final part
                if(aUseWildcards)
                        matchPos = dataSection.Match(aMatchType);
                else
                        matchPos = dataSection.Compare(aMatchType);

                }
        return matchPos != KErrNotFound;
        }

---