(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.2.10 and 1.1.2.11

version 1.1.2.10, 2004/09/24 14:33:20 version 1.1.2.11, 2004/09/24 19:37:52
Line 1 
Line 1 
 #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(){
  
Line 14 
Line 23 
 */ */
 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){ void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){
 printf("CQLFactory::makeObject(identifier)\n"); printf("CQLFactory::makeObject(identifier)\n");
         _chainedIdentifier = CQLChainedIdentifier(*obj);          _CQLObjectPtr._ptr = new CQLChainedIdentifier(*obj);
           _makeObjectChainedIdentifiers.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case ChainedIdentifier:           case ChainedIdentifier:
                 return &_chainedIdentifier;                  return _makeObjectChainedIdentifiers[_makeObjectChainedIdentifiers.size()-1]._ptr;
                 break;                 break;
           case Identifier:           case Identifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_chainedIdentifier, 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"); printf("CQLFactory::makeObject(chainedidentifier)\n");
         _value = CQLValue(*obj);          _CQLObjectPtr._ptr = new CQLValue(*obj);
           _makeObjectValues.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Value:           case Value:
                 return &_value;                  return _makeObjectValues[_makeObjectValues.size()-1]._ptr;
                 break;                 break;
           case ChainedIdentifier:           case ChainedIdentifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_value, 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"); printf("CQLFactory::makeObject(value)\n");
         _factor = CQLFactor(*obj);          _CQLObjectPtr._ptr = new CQLFactor(*obj);
         printf("%s\n",(const char*)_factor._rep->_CQLVal.toString().getCString());          _makeObjectFactors.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Factor:           case Factor:
                 return &_factor;                  return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
                 break;                 break;
           case Value:           case Value:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_factor, target);                  return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){ void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){
 printf("CQLFactory::makeObject(function)\n"); printf("CQLFactory::makeObject(function)\n");
         _factor = CQLFactor(*obj);          _CQLObjectPtr._ptr = new CQLFactor(*obj);
           _makeObjectFactors.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Factor:           case Factor:
                 return &_factor;                  return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
                 break;                 break;
           default:           default:
                 return makeObject(&_factor, target);                  return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
                 break;                 break;
         }         }
 } }
 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){ void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){
 printf("CQLFactory::makeObject(factor)\n"); printf("CQLFactory::makeObject(factor)\n");
         _term = CQLTerm(*obj);          _CQLObjectPtr._ptr = new CQLTerm(*obj);
           _makeObjectTerms.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Term:           case Term:
                 return &_term;                  return _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
                 break;                 break;
           case Factor:           case Factor:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_term, 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"); printf("CQLFactory::makeObject(term)\n");
         _expression = CQLExpression(*obj);          _CQLObjectPtr._ptr = new CQLExpression(*obj);
           _makeObjectExpressions.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Expression:           case Expression:
                 return &_expression;                  return _makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
                 break;                 break;
           case Term:           case Term:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_expression, 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"); printf("CQLFactory::makeObject(expression)\n");
         _simplePredicate = CQLSimplePredicate(*obj);          _CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
           _makeObjectSimplePredicates.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case SimplePredicate:           case SimplePredicate:
                 return &_simplePredicate;                  return _makeObjectSimplePredicates[_makeObjectSimplePredicates.size()-1]._ptr;
                 break;                 break;
           case Expression:           case Expression:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(&_simplePredicate, 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"); printf("CQLFactory::makeObject(simplepredicate)\n");
         _predicate = CQLPredicate(*obj);          _CQLObjectPtr._ptr = new CQLPredicate(*obj);
           _makeObjectPredicates.append(_CQLObjectPtr);
         switch(target){         switch(target){
           case Predicate:           case Predicate:
                 return &_predicate;                  return _makeObjectPredicates[_makeObjectPredicates.size()-1]._ptr;
                 break;                 break;
           default:           default:
                 return NULL;                 return NULL;
Line 197 
Line 213 
         switch(target){         switch(target){
           case Identifier:           case Identifier:
                 if(obj->_rep->_subIdentifiers.size() > 0){                 if(obj->_rep->_subIdentifiers.size() > 0){
                         _identifier = obj->_rep->_subIdentifiers[0];                          _CQLObjectPtr._ptr = new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
                         return &_identifier;                          _getObjectIdentifiers.append(_CQLObjectPtr);
                           return _getObjectIdentifiers[_getObjectIdentifiers.size()-1]._ptr;
                 }                 }
                 return NULL;                 return NULL;
           default:           default:
Line 210 
Line 227 
         printf("CQLFactory::getObject(CQLValue* obj)\n");         printf("CQLFactory::getObject(CQLValue* obj)\n");
         switch(target){         switch(target){
           case ChainedIdentifier:           case ChainedIdentifier:
                 _chainedIdentifier = obj->_CQLChainId;                  _CQLObjectPtr._ptr = new CQLChainedIdentifier(obj->_CQLChainId);
                 return &_chainedIdentifier;                  _getObjectChainedIdentifiers.append(_CQLObjectPtr);
                   return _getObjectChainedIdentifiers[_getObjectChainedIdentifiers.size()-1]._ptr;
           case Identifier:           case Identifier:
                 return getObject(&(obj->_CQLChainId),target);                 return getObject(&(obj->_CQLChainId),target);
           default:           default:
Line 224 
Line 242 
         printf("CQLFactory::getObject(CQLFactor* obj)\n");         printf("CQLFactory::getObject(CQLFactor* obj)\n");
         switch(target){         switch(target){
           case Function:           case Function:
                 _function = obj->_rep->_CQLFunct;                  _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
                 return &_function;                  _getObjectFunctions.append(_CQLObjectPtr);
                   return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
           case Value:           case Value:
                 _value = obj->_rep->_CQLVal;                  _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
                 return &_value;                  _getObjectValues.append(_CQLObjectPtr);
                   return _getObjectValues[_getObjectValues.size()-1]._ptr;
           case ChainedIdentifier:           case ChainedIdentifier:
           case Identifier:           case Identifier:
                 //_value = obj->_rep->_CQLVal;  
                 return getObject(&(obj->_rep->_CQLVal),target);                 return getObject(&(obj->_rep->_CQLVal),target);
           default:           default:
                 return NULL;                 return NULL;
Line 244 
Line 263 
         printf("CQLFactory::getObject(CQLTerm* obj)\n");         printf("CQLFactory::getObject(CQLTerm* obj)\n");
         switch(target){         switch(target){
           case Factor:           case Factor:
                 _factor = obj->getFactors()[0];                  _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
                 return &_factor;                  _getObjectFactors.append(_CQLObjectPtr);
                   return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
           case Function:           case Function:
           case Value:           case Value:
           case ChainedIdentifier:           case ChainedIdentifier:
           case Identifier:           case Identifier:
                 //_factor = obj->getFactors()[0];  
                 return getObject(&(obj->getFactors()[0]),target);                 return getObject(&(obj->getFactors()[0]),target);
           default:           default:
                 return NULL;                 return NULL;
Line 262 
Line 281 
         printf("CQLFactory::getObject(CQLExpression* obj)\n");         printf("CQLFactory::getObject(CQLExpression* obj)\n");
         switch(target){         switch(target){
           case Term:           case Term:
                 _term = obj->getTerms()[0];                  _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
                 return &_term;                  _getObjectTerms.append(_CQLObjectPtr);
                   return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
           case Factor:           case Factor:
           case Function:           case Function:
           case Value:           case Value:
           case ChainedIdentifier:           case ChainedIdentifier:
           case Identifier:           case Identifier:
                 //_term = obj->getTerms()[0];  
                 return getObject(&(obj->getTerms()[0]), target);                 return getObject(&(obj->getTerms()[0]), target);
           default:           default:
                 return NULL;                 return NULL;
Line 281 
Line 300 
         printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");         printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
         switch(target){         switch(target){
           case Expression:           case Expression:
                 _expression = obj->_rep->_leftSide;                  _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
                 return &_expression;                  _getObjectExpressions.append(_CQLObjectPtr);
                   return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
           case Term:           case Term:
           case Factor:           case Factor:
           case Function:           case Function:
           case Value:           case Value:
           case ChainedIdentifier:           case ChainedIdentifier:
           case Identifier:           case Identifier:
                 //_expression =  obj->getLeftExpression();  
                 return getObject(&(obj->_rep->_leftSide), target);                 return getObject(&(obj->_rep->_leftSide), target);
           default:           default:
                 return NULL;                 return NULL;
Line 301 
Line 320 
         printf("CQLFactory::getObject(CQLPredicate* obj)\n");         printf("CQLFactory::getObject(CQLPredicate* obj)\n");
         switch(target){         switch(target){
           case SimplePredicate:           case SimplePredicate:
                 _simplePredicate = obj->_rep->_simplePredicate;                  _CQLObjectPtr._ptr = new CQLSimplePredicate(obj->_rep->_simplePredicate);
                 return &_simplePredicate;                  _getObjectSimplePredicates.append(_CQLObjectPtr);
                 break;                  return _getObjectSimplePredicates[_getObjectSimplePredicates.size()-1]._ptr;
           case Expression:           case Expression:
           case Term:           case Term:
           case Factor:           case Factor:
Line 311 
Line 330 
           case Value:           case Value:
           case ChainedIdentifier:           case ChainedIdentifier:
           case Identifier:           case Identifier:
                 //_simplePredicate = obj->getSimplePredicate();  
                 return getObject(&(obj->_rep->_simplePredicate), target);                 return getObject(&(obj->_rep->_simplePredicate), target);
           default:           default:
                 return NULL;                 return NULL;

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