(file) Return to CQLFactory.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / CQL

Diff for /pegasus/src/Pegasus/CQL/CQLFactory.cpp between version 1.1 and 1.1.2.16

version 1.1, 2004/08/26 15:21:04 version 1.1.2.16, 2004/09/29 17:25:12
Line 1 
Line 1 
   //%2003////////////////////////////////////////////////////////////////////////
   //
   // 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.
   //
   // 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.
   //
   //==============================================================================
   //
   // Authors: David Rosckes (rosckes@us.ibm.com)
   //          Bert Rivero (hurivero@us.ibm.com)
   //          Chuck Carmack (carmack@us.ibm.com)
   //          Brian Lucier (lucier@us.ibm.com)
   //
   // Modified By:
   //
   //%/////////////////////////////////////////////////////////////////////////////
   
 #include "CQLFactory.h" #include "CQLFactory.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   struct CQLObjectPtr {
           void* _ptr;
   }_CQLObjectPtr;
   
   #define PEGASUS_ARRAY_T CQLObjectPtr
   #include <Pegasus/Common/ArrayImpl.h>
   #undef PEGASUS_ARRAY_T
   
   /*
   CQLFactory::CQLFactory(){
   
   }
   */
   CQLFactory::~CQLFactory(){
           cleanup();
   }
   
   void CQLFactory::cleanup(){
           cleanupArray(_makeObjectIdentifiers, Identifier);
           cleanupArray(_makeObjectChainedIdentifiers, ChainedIdentifier);
           cleanupArray(_makeObjectValues, Value);
           cleanupArray(_makeObjectFunctions, Function);
           cleanupArray(_makeObjectFactors, Factor);
           cleanupArray(_makeObjectTerms, Term);
           cleanupArray(_makeObjectExpressions, Expression);
           cleanupArray(_makeObjectSimplePredicates, SimplePredicate);
           cleanupArray(_makeObjectPredicates, Predicate);
           cleanupArray(_getObjectIdentifiers, Identifier);
           cleanupArray(_getObjectChainedIdentifiers, ChainedIdentifier);
           cleanupArray(_getObjectValues, Value);
           cleanupArray(_getObjectFunctions, Function);
           cleanupArray(_getObjectFactors, Factor);
           cleanupArray(_getObjectTerms, Term);
           cleanupArray(_getObjectExpressions, Expression);
           cleanupArray(_getObjectSimplePredicates, SimplePredicate);
           cleanupArray(_getObjectPredicates, Predicate);
   }
   void CQLFactory::cleanupArray(Array<CQLObjectPtr>& arr, FactoryType type){
           for(Uint32 i=0;i < arr.size(); i++){
                   if(arr[i]._ptr){
                           switch(type){
                              case Predicate:
                                   delete (CQLPredicate*)(arr[i]._ptr);
                                   break;
                              case SimplePredicate:
                                   delete (CQLSimplePredicate*)(arr[i]._ptr);
                                   break;
                              case Expression:
                                   delete (CQLExpression*)(arr[i]._ptr);
                                   break;
                              case Term:
                                   delete (CQLTerm*)(arr[i]._ptr);
                                   break;
                              case Factor:
                                   delete (CQLFactor*)(arr[i]._ptr);
                                   break;
                              case Function:
                                   delete (CQLFunction*)(arr[i]._ptr);
                                   break;
                              case Value:
                                   delete (CQLValue*)(arr[i]._ptr);
                                   break;
                              case ChainedIdentifier:
                                   delete (CQLChainedIdentifier*)(arr[i]._ptr);
                                   break;
                              case Identifier:
                                   delete (CQLIdentifier*)(arr[i]._ptr);
                                   break;
                           }
                   }
           }
   }
   
 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){ void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){
   //printf("CQLFactory::makeObject(identifier)\n");
           _CQLObjectPtr._ptr = new CQLChainedIdentifier(*obj);
           _makeObjectChainedIdentifiers.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case ChainedIdentifier:           case ChainedIdentifier:
                 return new CQLChainedIdentifier(*obj);                  return _makeObjectChainedIdentifiers[_makeObjectChainedIdentifiers.size()-1]._ptr;
                 break;                 break;
           case Identifier:           case Identifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLChainedIdentifier(*obj), target);                  return makeObject((CQLChainedIdentifier*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
 } }
 void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){ void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){
   //printf("CQLFactory::makeObject(chainedidentifier)\n");
           _CQLObjectPtr._ptr = new CQLValue(*obj);
           CQLValue* _val = (CQLValue*)_CQLObjectPtr._ptr;
           _makeObjectValues.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Value:           case Value:
                 return new CQLValue(*obj);                  return _makeObjectValues[_makeObjectValues.size()-1]._ptr;
                 break;                 break;
           case ChainedIdentifier:           case ChainedIdentifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLValue(*obj), target);                  return makeObject((CQLValue*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){ void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){
   //printf("CQLFactory::makeObject(value)\n");
           _CQLObjectPtr._ptr = new CQLFactor(*obj);
           _makeObjectFactors.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Factor:           case Factor:
                 return new CQLFactor(*obj);                  return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
                 break;                 break;
           case Value:           case Value:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLFactor(*obj), target);                  return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
   void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){
   //printf("CQLFactory::makeObject(function)\n");
           _CQLObjectPtr._ptr = new CQLFactor(*obj);
           _makeObjectFactors.append(_CQLObjectPtr);
           switch(target){
             case Factor:
                   return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
                   break;
             default:
                   return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
                   break;
           }
   }
 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){ void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){
   //printf("CQLFactory::makeObject(factor)\n");
           _CQLObjectPtr._ptr = new CQLTerm(*obj);
           _makeObjectTerms.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Term:           case Term:
                 return new CQLTerm(*obj);                  return _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
                 break;                 break;
           case Factor:           case Factor:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLTerm(*obj), target);                  return makeObject((CQLTerm*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){ void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){
   //printf("CQLFactory::makeObject(term)\n");
           _CQLObjectPtr._ptr = new CQLExpression(*obj);
           _makeObjectExpressions.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Expression:           case Expression:
                 return new CQLExpression(*obj);                  return _makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
                 break;                 break;
           case Term:           case Term:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLExpression(*obj), target);                  return makeObject((CQLExpression*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){ void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){
   //printf("CQLFactory::makeObject(expression)\n");
           _CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
           _makeObjectSimplePredicates.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case SimplePredicate:           case SimplePredicate:
                 return new CQLSimplePredicate(*obj);                  return _makeObjectSimplePredicates[_makeObjectSimplePredicates.size()-1]._ptr;
                 break;                 break;
           case Expression:           case Expression:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLSimplePredicate(*obj), target);                  return makeObject((CQLSimplePredicate*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){ void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){
   //printf("CQLFactory::makeObject(simplepredicate)\n");
           _CQLObjectPtr._ptr = new CQLPredicate(*obj);
           _makeObjectPredicates.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Predicate:           case Predicate:
                 return new CQLPredicate(*obj);                  return _makeObjectPredicates[_makeObjectPredicates.size()-1]._ptr;
                 break;                 break;
           default:           default:
                 return NULL;                 return NULL;
                 break;                 break;
         }         }
   }
  
   void* CQLFactory::getObject(void* inObject, FactoryType inObjectType, FactoryType targetType){
           switch(inObjectType){
                   case Predicate:
                           return getObject(((CQLPredicate*)inObject),targetType);
                   case SimplePredicate:
                           return getObject(((CQLSimplePredicate*)inObject),targetType);
                   case Expression:
                           return getObject(((CQLExpression*)inObject),targetType);
                   case Term:
                           return getObject(((CQLTerm*)inObject),targetType);
                   case Factor:
                           return getObject(((CQLFactor*)inObject),targetType);
                   case Function:
                           return NULL;
                   case Value:
                           return getObject(((CQLValue*)inObject),targetType);
                   case ChainedIdentifier:
                           return getObject(((CQLChainedIdentifier*)inObject),targetType);
                   default:
                           return NULL;
           }
   }
   
   void* CQLFactory::getObject(CQLChainedIdentifier* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLChainedIdentifier* obj)\n");
           switch(target){
             case Identifier:
                   if(obj->_rep->_subIdentifiers.size() > 0){
                           _CQLObjectPtr._ptr = new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
                           _getObjectIdentifiers.append(_CQLObjectPtr);
                           return _getObjectIdentifiers[_getObjectIdentifiers.size()-1]._ptr;
                   }
                   return NULL;
             default:
                   return NULL;
           }
 } }
  
   void* CQLFactory::getObject(CQLValue* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLValue* obj)\n");
           switch(target){
             case ChainedIdentifier:
                   _CQLObjectPtr._ptr = new CQLChainedIdentifier(obj->_rep->_CQLChainId);
                   _getObjectChainedIdentifiers.append(_CQLObjectPtr);
                   return _getObjectChainedIdentifiers[_getObjectChainedIdentifiers.size()-1]._ptr;
             case Identifier:
                   return getObject(&(obj->_rep->_CQLChainId),target);
             default:
                   return NULL;
                   break;
           }
   }
  
   void* CQLFactory::getObject(CQLFactor* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLFactor* obj)\n");
           switch(target){
             case Function:
                   _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
                   _getObjectFunctions.append(_CQLObjectPtr);
                   return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
             case Value:
                   _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
                   _getObjectValues.append(_CQLObjectPtr);
                   return _getObjectValues[_getObjectValues.size()-1]._ptr;
             case ChainedIdentifier:
             case Identifier:
                   return getObject(&(obj->_rep->_CQLVal),target);
             default:
                   return NULL;
                   break;
           }
   }
   
   
   void* CQLFactory::getObject(CQLTerm* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLTerm* obj)\n");
           switch(target){
             case Factor:
                   _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
                   _getObjectFactors.append(_CQLObjectPtr);
                   return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
             case Function:
             case Value:
             case ChainedIdentifier:
             case Identifier:
                   return getObject(&(obj->getFactors()[0]),target);
             default:
                   return NULL;
                   break;
           }
   }
   
   void* CQLFactory::getObject(CQLExpression* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLExpression* obj)\n");
           switch(target){
             case Term:
                   _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
                   _getObjectTerms.append(_CQLObjectPtr);
                   return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
             case Factor:
             case Function:
             case Value:
             case ChainedIdentifier:
             case Identifier:
                   return getObject(&(obj->getTerms()[0]), target);
             default:
                   return NULL;
                   break;
           }
   }
   
   void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
           switch(target){
             case Expression:
                   _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
                   _getObjectExpressions.append(_CQLObjectPtr);
                   return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
             case Term:
             case Factor:
             case Function:
             case Value:
             case ChainedIdentifier:
             case Identifier:
                   return getObject(&(obj->_rep->_leftSide), target);
             default:
                   return NULL;
                   break;
           }
   }
   
   void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target){
   //      printf("CQLFactory::getObject(CQLPredicate* obj)\n");
           switch(target){
             case SimplePredicate:
                   _CQLObjectPtr._ptr = new CQLSimplePredicate(obj->_rep->_simplePredicate);
                   _getObjectSimplePredicates.append(_CQLObjectPtr);
                   return _getObjectSimplePredicates[_getObjectSimplePredicates.size()-1]._ptr;
             case Expression:
             case Term:
             case Factor:
             case Function:
             case Value:
             case ChainedIdentifier:
             case Identifier:
                   return getObject(&(obj->_rep->_simplePredicate), target);
             default:
                   return NULL;
                   break;
           }
   }
   
   void CQLFactory::setObject(CQLPredicate* predicate, void* obj, FactoryType objType){
           switch(objType){
             case SimplePredicate:
                   predicate->_rep->_simplePredicate = *((CQLSimplePredicate*)obj);
                   break;
             case Expression:
                   predicate->_rep->_simplePredicate._rep->_leftSide = *((CQLExpression*)obj);
                   break;
             case Term:
                   predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0] =
                           *((CQLTerm*)obj);
                   break;
             case Factor:
                   predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0] =
                           *((CQLFactor*)obj);
                   break;
             case Function:
                   predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLFunct =
                           *((CQLFunction*)obj);
                   break;
             case Value:
                   predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal =
                           *((CQLValue*)obj);
                   break;
             case ChainedIdentifier:
                   predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal._rep->_CQLChainId = *((CQLChainedIdentifier*)obj);
                   break;
             case Identifier:
                   break;
             default:
                   break;
           }
   }
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.1.2.16
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2