Return to CMPI_ContextArgs.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

BUG#: 6354
TITLE: TestCMPIMethod fails

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/CIMNameUnchecked.h>
#include "CMPI_Version.h" 

#include "CMPI_ContextArgs.h"
#include "CMPI_Ftabs.h"
#include "CMPI_Value.h"
#include "CMPI_String.h"

#include <string.h>

PEGASUS_USING_STD;
PEGASUS_NAMESPACE_BEGIN

// CMPIArgs section

extern "C" {

   static CMPIStatus argsRelease(CMPIArgs* eArg) 
   {
      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
      if (arg) {
         delete arg;
         (reinterpret_cast<CMPI_Object*>(eArg))->unlinkAndDelete();
      CMReturn(CMPI_RC_OK);
   }
      CMReturn(CMPI_RC_ERR_INVALID_HANDLE); 
   }

   static CMPIStatus argsReleaseNop(CMPIArgs* eArg) {
      CMReturn(CMPI_RC_OK);
   }

   static CMPIArgs* argsClone(const CMPIArgs* eArg, CMPIStatus* rc) 
   {
      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
      if (!arg)
      {
          CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
          return 0;
      }
      Array<CIMParamValue>* cArg=new Array<CIMParamValue>();
      for (long i=0,s=arg->size(); i<s; i++) {
         const CIMParamValue &v=(*arg)[i];
         cArg->append(v.clone());
      }
      CMPI_Object* obj=new CMPI_Object(cArg);
      obj->unlink();
      CMPIArgs* neArg=reinterpret_cast<CMPIArgs*>(obj);
      if (rc) CMSetStatus(rc,CMPI_RC_OK);
      return neArg;
   }

   static long locateArg(const Array<CIMParamValue> &a, const CIMName &eName) {
      for (long i=0,s=a.size(); i<s; i++) {
         const String &n=a[i].getParameterName();
         if (String::equalNoCase(n,eName.getString())) return i;
      }
      return -1;
   }

   static CMPIStatus argsAddArg(const CMPIArgs* eArg, const char *name, 
                                const CMPIValue* data,  const CMPIType type) 
   {
      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
      if (!arg)
      {
          CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
      }
      if (!name)
      {
          CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
      }
      CMPIrc rc;
      CIMValue v=value2CIMValue(data,type,&rc);
      CIMName sName(name);

      long i=locateArg(*arg,sName);
      if (i>=0) arg->remove(i);

      arg->append(CIMParamValue(sName.getString(),v));
      CMReturn(CMPI_RC_OK);
   }

   static CMPIData argsGetArgAt(const CMPIArgs* eArg, CMPICount pos, 
				CMPIString** name,
				CMPIStatus* rc) 
   {

      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
      CMPIData data={0,CMPI_nullValue | CMPI_notFound,{0}};
      if (!arg)
      {
          CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
          return data;
      }

      if (pos > arg->size()) 
      {
         CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);
         return data;
      }

      CIMValue v=(*arg)[pos].getValue();
      CIMType pType=v.getType();
      CMPIType t=type2CMPIType(pType,v.isArray());

      value2CMPIData(v,t,&data);

      if (name) {
         String n=(*arg)[pos].getParameterName();
         *name=(CMPIString*)string2CMPIString(n);
      }

      if (rc) CMSetStatus(rc,CMPI_RC_OK);
      return data;
   }

   static CMPIData argsGetArg(const CMPIArgs* eArg, const char *name, 
                              CMPIStatus* rc) 
   {
      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
       CMPIData data={0,CMPI_nullValue | CMPI_notFound,{0}};
       if (!arg)
       {
           CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
           return data;
       }
       if (!name)
       {
           CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
           return data;
       }
      CIMNameUnchecked eName(name);

      long i=locateArg(*arg,eName);
      if (i>=0) return argsGetArgAt(eArg,i,NULL,rc);

       CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);
      return data;
   }

   static CMPICount argsGetArgCount(const CMPIArgs* eArg, CMPIStatus* rc) 
   {
      Array<CIMParamValue>* arg=(Array<CIMParamValue>*)eArg->hdl;
      if (!arg)
      {
          CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
          return 0;
      }
      CMSetStatus(rc,CMPI_RC_OK);
      return arg->size();
   }

}

static CMPIArgsFT args_FT={
     CMPICurrentVersion,
     argsRelease,
     argsClone,
     argsAddArg,
     argsGetArg,
     argsGetArgAt,
     argsGetArgCount,
};

CMPIArgsFT *CMPI_Args_Ftab=&args_FT;

static CMPIArgsFT argsOnStack_FT={
     CMPICurrentVersion,
     argsReleaseNop,
     argsClone,
     argsAddArg,
     argsGetArg,
     argsGetArgAt,
     argsGetArgCount,
};

CMPIArgsFT *CMPI_ArgsOnStack_Ftab=&argsOnStack_FT;



// CMPIContext Session

extern "C" {

static CMPIStatus contextReleaseNop(CMPIContext* eCtx) {
   CMReturn(CMPI_RC_OK);
}

   static CMPIData contextGetEntry(const CMPIContext* eCtx, const char *name, CMPIStatus* rc) {
      return argsGetArg(reinterpret_cast<const CMPIArgs*>(eCtx),name,rc);
   }

   CMPIData contextGetEntryAt(const CMPIContext* eCtx, CMPICount pos,
               CMPIString** name, CMPIStatus* rc) {
      return argsGetArgAt(reinterpret_cast<const CMPIArgs*>(eCtx),pos,name,rc);
   }

   static CMPICount contextGetEntryCount(const CMPIContext* eCtx, CMPIStatus* rc) {
      return argsGetArgCount(reinterpret_cast<const CMPIArgs*>(eCtx),rc);
   }

   static CMPIStatus contextAddEntry(const CMPIContext* eCtx, const char *name,
               const CMPIValue* data,  const CMPIType type) 
   {
      if (!name || !data)
      {
          CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
      }
      if (strcmp(name,SnmpTrapOidContainer::NAME.getCString())==0) 
      {         
         OperationContext *ctx=((CMPI_Context*)eCtx)->ctx;
         if (!ctx)
         {
             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
         }
         if (type==CMPI_chars) {
            ctx->insert(SnmpTrapOidContainer((char*)data));
            CMReturn(CMPI_RC_OK);
         }
         else if (type==CMPI_string) {
            ctx->insert(SnmpTrapOidContainer((char*)data->string->hdl));
            CMReturn(CMPI_RC_OK);
         }
         else
         {   // Only CMPITypes CMPI_chars and CMPI_string are supported
             // for SnmpTrapOidContainer.
             CMReturn(CMPI_RC_ERR_INVALID_DATA_TYPE); 
         }
      }
      return argsAddArg(reinterpret_cast<const CMPIArgs*>(eCtx),name,data,type);
   }

}

static CMPIContextFT context_FT={
     CMPICurrentVersion,
     contextReleaseNop,
     NULL,
     contextGetEntry,
     contextGetEntryAt,
     contextGetEntryCount,
     contextAddEntry,
};

CMPIContextFT *CMPI_Context_Ftab=&context_FT;

static CMPIContextFT contextOnStack_FT={
     CMPICurrentVersion,
     contextReleaseNop,
     NULL,
     contextGetEntry,
     contextGetEntryAt,
     contextGetEntryCount,
     contextAddEntry,
};

CMPIContextFT *CMPI_ContextOnStack_Ftab=&contextOnStack_FT;


CMPI_Context::CMPI_Context(const OperationContext& ct) {
      ctx=(OperationContext*)&ct;
      thr=NULL;
      hdl=(void*)new Array<CIMParamValue>();
      ft=CMPI_Context_Ftab;
   }
CMPI_Context::~CMPI_Context() {
      delete (Array<CIMParamValue>*)hdl;
      delete ctx;
}
CMPI_ContextOnStack::CMPI_ContextOnStack(const OperationContext& ct) {
      ctx=(OperationContext*)&ct;
      hdl=(void*)new Array<CIMParamValue>();
      ft=CMPI_ContextOnStack_Ftab;
   }

CMPI_ContextOnStack::~CMPI_ContextOnStack() {
      delete (Array<CIMParamValue>*)hdl;
   }

CMPI_ArgsOnStack::CMPI_ArgsOnStack(const Array<CIMParamValue>& args) {
      hdl=(void*)&args;
      ft=CMPI_ArgsOnStack_Ftab;
   }

PEGASUS_NAMESPACE_END