/*
* 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.
*/
/**
* @author Neeraj Joshi <jneeraj@us.ibm.com>
*
*/
package org.apache.imperius.cimspl.client;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.imperius.spl.core.Actuator;
import org.apache.imperius.spl.core.Argument;
import org.apache.imperius.spl.parser.exceptions.InvalidCIMParameterException;
import org.apache.imperius.spl.parser.exceptions.SPLException;
import org.apache.imperius.util.SPLLogger;
import org.sblim.wbem.cim.CIMArgument;
import org.sblim.wbem.cim.CIMClass;
import org.sblim.wbem.cim.CIMDataType;
import org.sblim.wbem.cim.CIMDateTime;
import org.sblim.wbem.cim.CIMException;
import org.sblim.wbem.cim.CIMInstance;
import org.sblim.wbem.cim.CIMMethod;
import org.sblim.wbem.cim.CIMObjectPath;
import org.sblim.wbem.cim.CIMParameter;
import org.sblim.wbem.cim.CIMProperty;
import org.sblim.wbem.cim.CIMSimpleDateTime;
import org.sblim.wbem.cim.CIMValue;
import org.sblim.wbem.cim.UnsignedInt16;
import org.sblim.wbem.cim.UnsignedInt32;
import org.sblim.wbem.cim.UnsignedInt64;
import org.sblim.wbem.cim.UnsignedInt8;
import org.sblim.wbem.client.CIMClient;
public class CIMClientSideActuatorImpl implements Actuator
{
private static CIMClient handle = null;
private static final String sourceClass="ActuatorImpl";
private static Logger logger = SPLLogger.getSPLLogger().getLogger();
public CIMClientSideActuatorImpl(CIMClient ch)
{
handle=ch;
}
//instanceKeys is a Map containing (name,value) pairs, inParameters and outParameters are maps that have (name,value) pairs which are the arguments for the method
public Object invokeMethod(String className,String namespace,Object instance,String methodName, List inParameterValues) throws SPLException {
logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "invokeMethod");
Vector inParams=new Vector();
Vector outParams=new Vector();
CIMObjectPath cop=new CIMObjectPath(className,namespace);
if(className!=null && namespace!=null){
try
{
Iterator it=inParameterValues.iterator();
Map cimArgNameValuePairs= new HashMap();
while(it.hasNext())
{
Argument arg=(Argument)it.next();
cimArgNameValuePairs.put(arg.getName(), arg.getValue());
//System.out.println(" added to cimArgNameValuePairs : "+arg.getName()+ " "+arg.getValue().toString());
}
if(instance instanceof CIMObjectPath)
{
cop=(CIMObjectPath)instance;
CIMObjectPath classCop=new CIMObjectPath(className,namespace);
CIMClass cimclass=handle.getClass(classCop, true, true, true, null);
CIMMethod cimMethod= cimclass.getMethod(methodName);
Vector params = cimMethod.getParameters();
for(int j=0;j<params.size();j++)
{
CIMParameter cimparameter=(CIMParameter)params.get(j);
String parameterName=cimparameter.getName();
int type=cimparameter.getType().getType();
//boolean isArray=cimparameter.isArray();
//System.out.println("parameter name = "+parameterName);
Object paramValue=cimArgNameValuePairs.get(parameterName);
if(paramValue!=null){
CIMValue cv=getCIMObjectOfGivenType(type, paramValue);
//System.out.println("parameter value = "+paramValue+ " "+cv.toString());
//new CIMArgument(parameterName,cv);
inParams.add(new CIMArgument(parameterName,cv));
}
else
{
//System.out.println("value = null");
}
}
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" Actuator::invokeMethod:invoking method "+methodName);
CIMObjectPath instanceCop=new CIMObjectPath(className,namespace);
instanceCop.setKeys(cop.getKeys());
//System.out.println("cop, methodName :"+instanceCop+" "+ methodName);
CIMValue cv=handle.invokeMethod(instanceCop, methodName, inParams, outParams);
//System.out.println("invokeMethod complete : return value="+cv.getValue());
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" Actuator::invokeMethod:done invoking method");
if(logger.isLoggable(Level.FINE))
logger.fine(outParams.toString());
logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "invokeMethod");
Integer returnVal=new Integer(1);
return returnVal;
}
else{
logger.severe(Thread.currentThread().getName()+" "+"instance for method invokation is not of type CIMObjectPath");
throw new SPLException("instance for method invokation is not of type CIMObjectPath");
}
}
catch(CIMException e){
e.printStackTrace();
//System.out.println(e.getMessage());
logger.severe(Thread.currentThread().getName()+" "+"invokeMethod Failed "+methodName+" "+ className+ " " + namespace+" "+e.getMessage());
throw new SPLException("invokeMethod Failed"+methodName+" "+ className+ " " + namespace +" "+ e.getMessage());
}
}
else {
logger.severe(Thread.currentThread().getName()+" "+"This CIM class is not handled by the Policy Provider");
throw new InvalidCIMParameterException("This CIM class is not handled by the Policy Provider");
}
}
//_className, qualifier, instance, modifiedProperties
public void modifyInstance(String className,String namespace,
Object instance, Map properties) throws SPLException
{
logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "modifyInstance");
if(className!=null && namespace!=null)
{
try
{
if(instance instanceof CIMObjectPath)
{
CIMObjectPath copTemp=(CIMObjectPath)instance;
CIMObjectPath cop=new CIMObjectPath(className,namespace);
cop.setKeys(copTemp.getKeys());
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" Actuator::Modify instance :cop"+cop);
CIMInstance cimInstance= null;
try
{
cimInstance=handle.getInstance(cop, true, true, true, null);
}
catch(CIMException e)
{
logger.severe(Thread.currentThread().getName()+" "+
"instance does not belong to Anchor Class, might be of an extension of Anchor class, " +
"no action will be taken on it. "+e.getMessage());
throw new SPLException("instance does not belong to Anchor Class, might be of an " +
"extension of Anchor class, no action will be taken on it. "+e.getMessage());
}
if(cimInstance != null)
{
Vector modifiedProperties = new Vector();
Vector instanceProperties = cimInstance.getAllProperties();
Set propertyNames = properties.keySet();
Iterator propertyIterator = propertyNames.iterator();
while(propertyIterator.hasNext())
{
String keyName = (String)propertyIterator.next();
Object keyValue = properties.get(keyName);
Iterator instancePropertyIterator = instanceProperties.iterator();
while(instancePropertyIterator.hasNext())
{
CIMProperty cimprop=(CIMProperty)instancePropertyIterator.next();
String name=cimprop.getName();
int type=cimprop.getType().getType();
// boolean isArray=cimprop.isArray();
CIMValue instValue=cimprop.getValue();
if(cimprop.getName().equalsIgnoreCase(keyName))
{
Object cimKeyValue = keyValue;
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+
" Instance property:: Name,Type,Value,CIMKeyValue :"+name+" "+type+" "
+instValue+" "+ cimKeyValue.getClass());
CIMValue cimval = getCIMObjectOfGivenType(type,cimKeyValue);
cimprop.setValue(cimval);
handle.setProperty(cimInstance.getObjectPath(), keyName, cimval);
modifiedProperties.add(cimprop);
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" cimprop set to cimValue "+cimval.getValue());
}
}
}
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" done setting all properties");
// cimInstance.setProperties(modifiedProperties);
// handle.setInstance(cop, cimInstance);
// handle.modifyInstance(cop, cimInstance, true, null);
if(logger.isLoggable(Level.FINE))
logger.fine(Thread.currentThread().getName()+" done modifying CIMInstance");
logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "modifyInstance");
}
}
else
{
logger.severe(Thread.currentThread().getName()+" "+"instance for method invokation is not of type CIMObjectPath");
throw new SPLException("instance for method invokation is not of type CIMObjectPath");
}
}
catch(CIMException e){
e.printStackTrace();
logger.severe(Thread.currentThread().getName()+" "+"modify instance Failed :"+ className+ " " + namespace);
throw new SPLException("modify Instance Failed :"+ className+ " " + namespace);
}
}
else {
logger.severe(Thread.currentThread().getName()+" "+"This CIM class is not handled by the Policy Provider");
throw new InvalidCIMParameterException("This CIM class is not handled by the Policy Provider");
}
}
public void init(CIMClient ch) throws SPLException {
logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "init");
handle=ch;
logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "init");
}
/* (non-Javadoc)
* @see com.ibm.pegasus.cimspl.helper.DataCollector#shutDown()
*/
public void shutDown() {
logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "init");
logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "init");
}
private CIMValue getCIMObjectOfGivenType(int type, Object CIMKeyValue)
throws CIMException,SPLException
{
CIMValue cimval=null;
switch(type)
{
case CIMDataType.UINT8_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List uintArray=new ArrayList();
while(arrayIt.hasNext())
{
Short sht=new Short(Short.parseShort((arrayIt.next()).toString()));
UnsignedInt8 uint8= new UnsignedInt8(sht.shortValue());
uintArray.add(uint8);
}
Object actualValue=(UnsignedInt8[])uintArray.toArray();
CIMDataType uint8ArrType = new CIMDataType(CIMDataType.UINT8_ARRAY);
cimval=new CIMValue(actualValue, uint8ArrType);
}
break;
case CIMDataType.UINT16_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List uintArray=new ArrayList();
while(arrayIt.hasNext())
{
Integer integ=new Integer(Integer.parseInt((arrayIt.next()).toString()));
UnsignedInt16 uint16= new UnsignedInt16(integ.intValue());
uintArray.add(uint16);
}
Object actualValue=(UnsignedInt16[])uintArray.toArray();
CIMDataType uint16ArrType = new CIMDataType(CIMDataType.UINT16_ARRAY);
cimval=new CIMValue(actualValue,uint16ArrType);
}
break;
case CIMDataType.UINT32_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List uintArray=new ArrayList();
while(arrayIt.hasNext())
{
Long lng=new Long(Long.parseLong((arrayIt.next()).toString()));
UnsignedInt32 uint32= new UnsignedInt32(lng.longValue());
uintArray.add(uint32);
}
Object actualValue=(UnsignedInt32[])uintArray.toArray();
CIMDataType uint32ArrType = new CIMDataType(CIMDataType.UINT32_ARRAY);
cimval=new CIMValue(actualValue,uint32ArrType);
}
break;
case CIMDataType.UINT64_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List uintArray=new ArrayList();
while(arrayIt.hasNext())
{
Long lng=new Long(Long.parseLong((arrayIt.next()).toString()));
BigInteger big=BigInteger.valueOf(lng.longValue());
UnsignedInt64 uint64= new UnsignedInt64(big.abs());
uintArray.add(uint64);
}
Object actualValue=(UnsignedInt64[])uintArray.toArray();
CIMDataType uint64ArrType = new CIMDataType(CIMDataType.UINT64_ARRAY);
cimval=new CIMValue(actualValue,uint64ArrType);
}
break;
case CIMDataType.SINT8_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Byte bt=new Byte(Byte.parseByte((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Byte[])sintArray.toArray();
CIMDataType sint8ArrType = new CIMDataType(CIMDataType.SINT8_ARRAY);
cimval=new CIMValue(actualValue,sint8ArrType);
}
break;
case CIMDataType.SINT16_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Short bt=new Short(Short.parseShort((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Short[])sintArray.toArray();
CIMDataType sint16ArrType = new CIMDataType(CIMDataType.SINT16_ARRAY);
cimval=new CIMValue(actualValue,sint16ArrType);
}
break;
case CIMDataType.SINT32_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Integer bt=new Integer(Integer.parseInt((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Integer[])sintArray.toArray();
CIMDataType sint32ArrType = new CIMDataType(CIMDataType.SINT32_ARRAY);
cimval=new CIMValue(actualValue,sint32ArrType);
}
break;
case CIMDataType.SINT64_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext()){
Long bt=new Long(Long.parseLong((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Long[])sintArray.toArray();
CIMDataType sint64ArrType = new CIMDataType(CIMDataType.SINT64_ARRAY);
cimval=new CIMValue(actualValue,sint64ArrType);
}
break;
case CIMDataType.REAL32_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Float bt=new Float(Float.parseFloat((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Float[])sintArray.toArray();
CIMDataType real32ArrType = new CIMDataType(CIMDataType.REAL32_ARRAY);
cimval=new CIMValue(actualValue,real32ArrType);
}
break;
case CIMDataType.REAL64_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Double bt=new Double(Double.parseDouble((arrayIt.next()).toString()));
sintArray.add(bt);
}
Object actualValue=(Double[])sintArray.toArray();
CIMDataType real64ArrType = new CIMDataType(CIMDataType.REAL64_ARRAY);
cimval=new CIMValue(actualValue,real64ArrType);
}
break;
case CIMDataType.BOOLEAN_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Boolean bt=Boolean.valueOf((arrayIt.next()).toString());
sintArray.add(bt);
}
Object actualValue=(Boolean[])sintArray.toArray();
CIMDataType boolArrType = new CIMDataType(CIMDataType.BOOLEAN_ARRAY);
cimval=new CIMValue(actualValue,boolArrType);
}
break;
case CIMDataType.CHAR16_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
Character bt=new Character(((arrayIt.next()).toString()).charAt(0));
sintArray.add(bt);
}
Object actualValue=(Character[])sintArray.toArray();
CIMDataType char16ArrType = new CIMDataType(CIMDataType.CHAR16_ARRAY);
cimval=new CIMValue(actualValue,char16ArrType);
}
break;
case CIMDataType.STRING_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List sintArray=new ArrayList();
while(arrayIt.hasNext())
{
String bt=(arrayIt.next()).toString();
sintArray.add(bt);
}
Object actualValue=(String[])sintArray.toArray();
CIMDataType stringArrType = new CIMDataType(CIMDataType.STRING_ARRAY);
cimval=new CIMValue(actualValue,stringArrType);
}
break;
case CIMDataType.DATETIME_ARRAY:
{
if(!(CIMKeyValue instanceof List))
{
logger.severe(Thread.currentThread().getName()+" "+"expected a List");
throw new SPLException("expected a List");
}
List intArray=(List)CIMKeyValue;
Iterator arrayIt=intArray.iterator();
List cimDateTimeArray=new ArrayList();
while(arrayIt.hasNext())
{
Object ob=arrayIt.next();
if(!(ob instanceof Calendar)){
throw new SPLException("Value should be of type Calendar");
}
Calendar cal=(Calendar)ob;
CIMDateTime calCIM=new CIMSimpleDateTime(cal);
cimDateTimeArray.add(calCIM);
}
Object actualValue=(CIMDateTime[])cimDateTimeArray.toArray();
CIMDataType calArrType = new CIMDataType(CIMDataType.DATETIME_ARRAY);
cimval=new CIMValue(actualValue,calArrType);
}
break;
case CIMDataType.UINT8:
{
Short sht=new Short(Short.parseShort(CIMKeyValue.toString()));
UnsignedInt8 uint8= new UnsignedInt8(sht.shortValue());
CIMDataType uint8Type = new CIMDataType(CIMDataType.UINT8);
cimval=new CIMValue(uint8,uint8Type);
}
break;
case CIMDataType.UINT16:
{
Integer integ=new Integer(Integer.parseInt(CIMKeyValue.toString()));
UnsignedInt16 uint16= new UnsignedInt16(integ.intValue());
CIMDataType uint16Type = new CIMDataType(CIMDataType.UINT16);
cimval=new CIMValue(uint16,uint16Type);
}
break;
case CIMDataType.UINT32:
{
Long lng=new Long(Long.parseLong(CIMKeyValue.toString()));
UnsignedInt32 uint32= new UnsignedInt32(lng.longValue());
CIMDataType uint32Type = new CIMDataType(CIMDataType.UINT32);
cimval=new CIMValue(uint32,uint32Type);
}
break;
case CIMDataType.UINT64:
{
Long shrt=new Long(Long.parseLong(CIMKeyValue.toString()));
BigInteger big=BigInteger.valueOf(shrt.longValue());
UnsignedInt64 uint64= new UnsignedInt64(big.abs());
CIMDataType uint64Type = new CIMDataType(CIMDataType.UINT64);
cimval=new CIMValue(uint64,uint64Type);
}
break;
case CIMDataType.SINT8:
{
Byte byt=new Byte(Byte.parseByte(CIMKeyValue.toString()));
CIMDataType sint8Type = new CIMDataType(CIMDataType.SINT8);
cimval=new CIMValue(byt,sint8Type);
}
break;
case CIMDataType.SINT16:
{
Short sht=new Short(Short.parseShort(CIMKeyValue.toString()));
CIMDataType sint16Type = new CIMDataType(CIMDataType.SINT16);
cimval=new CIMValue(sht,sint16Type);
}
break;
case CIMDataType.SINT32:
{
Integer integ=new Integer(Integer.parseInt(CIMKeyValue.toString()));
CIMDataType sint32Type = new CIMDataType(CIMDataType.SINT32);
cimval=new CIMValue(integ,sint32Type);
}
break;
case CIMDataType.SINT64:
{
Long lng=new Long(Long.parseLong(CIMKeyValue.toString()));
CIMDataType sint64Type = new CIMDataType(CIMDataType.SINT64);
cimval=new CIMValue(lng,sint64Type);
}
break;
case CIMDataType.REAL32:
{
Float flt=new Float(Float.parseFloat(CIMKeyValue.toString()));
CIMDataType real32Type = new CIMDataType(CIMDataType.REAL32);
cimval=new CIMValue(flt,real32Type);
}
break;
case CIMDataType.REAL64:
{
Double dbl=new Double(Double.parseDouble(CIMKeyValue.toString()));
CIMDataType real64Type = new CIMDataType(CIMDataType.REAL64);
cimval=new CIMValue(dbl,real64Type);
}
break;
case CIMDataType.CHAR16:
{
Character cha=new Character((CIMKeyValue.toString()).charAt(0));
CIMDataType char16Type = new CIMDataType(CIMDataType.CHAR16);
cimval=new CIMValue(cha,char16Type);
}
break;
case CIMDataType.BOOLEAN:
{
Boolean booln=Boolean.valueOf(CIMKeyValue.toString());
CIMDataType boolType = new CIMDataType(CIMDataType.BOOLEAN);
cimval=new CIMValue(booln,boolType);
}
break;
case CIMDataType.STRING:
{
String str=CIMKeyValue.toString();
CIMDataType stringType = new CIMDataType(CIMDataType.STRING);
cimval=new CIMValue(str,stringType);
}
break;
case CIMDataType.DATETIME:
{
if(!(CIMKeyValue instanceof Calendar)){
throw new SPLException("Value should be of type Calendar");
}
Calendar cal=(Calendar)CIMKeyValue;
CIMDateTime calCIM=new CIMSimpleDateTime(cal);
CIMDataType calType = new CIMDataType(CIMDataType.DATETIME);
cimval=new CIMValue(calCIM,calType);
}
break;
default:
throw new SPLException("invalid type " + type);
}
return cimval;
}
}