(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.7

version 1.1, 2004/08/26 15:21:04 version 1.1.2.7, 2004/09/16 21:00:34
Line 3 
Line 3 
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){ void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){
           CQLChainedIdentifier _cid(*obj);
         switch(target){         switch(target){
           case ChainedIdentifier:           case ChainedIdentifier:
                 return new CQLChainedIdentifier(*obj);                  _chainedIdentifier = _cid;
                   return &_chainedIdentifier;
                 break;                 break;
           case Identifier:           case Identifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLChainedIdentifier(*obj), target);                  return makeObject(&_chainedIdentifier, target);
                 break;                 break;
         }         }
 } }
 void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){ void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){
           CQLValue _val(*obj);
         switch(target){         switch(target){
           case Value:           case Value:
                 return new CQLValue(*obj);                  _value = _val;
                   return &_value;
                 break;                 break;
           case ChainedIdentifier:           case ChainedIdentifier:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLValue(*obj), target);                  return makeObject(&_value, target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){ void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){
           CQLFactor _fctr(*obj);
         switch(target){         switch(target){
           case Factor:           case Factor:
                 return new CQLFactor(*obj);                  _factor = _fctr;
                   return &_factor;
                 break;                 break;
           case Value:           case Value:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLFactor(*obj), target);                  return makeObject(&_factor, target);
                 break;                 break;
         }         }
  
 } }
   void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){
           CQLFactor _fctr(*obj);
           switch(target){
             case Factor:
                   _factor = _fctr;
                   return &_factor;
                   break;
             default:
                   return makeObject(&_factor, target);
                   break;
           }
   }
 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){ void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){
           CQLTerm _trm(*obj);
         switch(target){         switch(target){
           case Term:           case Term:
                 return new CQLTerm(*obj);                  _term = _trm;
                   return &_term;
                 break;                 break;
           case Factor:           case Factor:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLTerm(*obj), target);                  return makeObject(&_term, target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){ void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){
           CQLExpression _expr(*obj);
         switch(target){         switch(target){
           case Expression:           case Expression:
                 return new CQLExpression(*obj);                  _expression = _expr;
                   return &_expression;
                 break;                 break;
           case Term:           case Term:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLExpression(*obj), target);                  return makeObject(&_expression, target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){ void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){
           CQLSimplePredicate _sp(*obj);
         switch(target){         switch(target){
           case SimplePredicate:           case SimplePredicate:
                 return new CQLSimplePredicate(*obj);                  _simplePredicate = _sp;
                   return &_simplePredicate;
                 break;                 break;
           case Expression:           case Expression:
                 return NULL;                 return NULL;
                 break;                 break;
           default:           default:
                 return makeObject(new CQLSimplePredicate(*obj), target);                  return makeObject(&_simplePredicate, target);
                 break;                 break;
         }         }
  
 } }
 void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){ void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){
           CQLPredicate _pred(*obj);
         switch(target){         switch(target){
           case Predicate:           case Predicate:
                 return new CQLPredicate(*obj);                  _predicate = _pred;
                   return &_predicate;
                   break;
             default:
                   return NULL;
                   break;
           }
   }
   
   CQLValue CQLFactory::getValue(CQLFactor* obj){
           if(obj->isSimpleValue()){
                   return obj->getValue();
           }
           return CQLValue();
   }
   
   CQLValue CQLFactory::getValue(CQLTerm* obj){
           if(obj->isSimpleValue()){
                    _factor = obj->getFactors()[0];
                   return getValue(&_factor);
           }
           return CQLValue();
   }
   
   CQLValue CQLFactory::getValue(CQLExpression* obj){
           if(obj->isSimpleValue()){
                    _term = (obj->getTerms())[0];
                   return getValue(&_term);
           }
           return CQLValue();
   }
   
   CQLValue CQLFactory::getValue(CQLSimplePredicate* obj){
           _expression = obj->getLeftExpression();
           return getValue(&_expression);
   }
   
   CQLValue CQLFactory::getValue(CQLPredicate* obj){
           if(obj->isSimple()){
                   _simplePredicate = obj->getSimplePredicate();
                   return getValue(&_simplePredicate);
           }
           return CQLValue();
   }
   
   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){
           switch(target){
             case Identifier:
                   if(obj->_rep->_subIdentifiers.size() > 0){
                           _identifier = obj->_rep->_subIdentifiers[0];
                           return &_identifier;
                   }
                   return NULL;
             default:
                   return NULL;
           }
   }
   
   void* CQLFactory::getObject(CQLValue* obj, FactoryType target){
           switch(target){
             case ChainedIdentifier:
                   _chainedIdentifier = obj->getChainedIdentifier();
                   return &_chainedIdentifier;
             default:
                   return NULL;
                   break;
           }
   }
   
   void* CQLFactory::getObject(CQLFactor* obj, FactoryType target){
           switch(target){
             case Function:
                   _function =  obj->getCQLFunction();
                   return &_function;
             default:
                   return NULL;
                   break;
           }
   }
   
   
   void* CQLFactory::getObject(CQLTerm* obj, FactoryType target){
           switch(target){
             case Factor:
                   _factor = obj->getFactors()[0];
                   return &_factor;
             case Function:
                   _factor = obj->getFactors()[0];
                   return getObject(&_factor,target);
             default:
                   return NULL;
                 break;                 break;
           }
   }
   
   void* CQLFactory::getObject(CQLExpression* obj, FactoryType target){
           switch(target){
             case Term:
                   _term = obj->getTerms()[0];
                   return &_term;
             case Factor:
             case Function:
                   _term = obj->getTerms()[0];
                   return getObject(&_term, target);
             default:
                   return NULL;
                   break;
           }
   }
   
   void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target){
           switch(target){
             case Expression:
                   _expression =  obj->getLeftExpression();
             case Term:
             case Factor:
             case Function:
                   _expression =  obj->getLeftExpression();
                   return getObject(&_expression, target);
           default:           default:
                 return NULL;                 return NULL;
                 break;                 break;
         }         }
   }
  
   void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target){
           switch(target){
             case SimplePredicate:
                   _simplePredicate = obj->getSimplePredicate();
                   return &_simplePredicate;
                   break;
             case Expression:
             case Term:
             case Factor:
             case Function:
                   _simplePredicate = obj->getSimplePredicate();
                   return getObject(&_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;
             default:
                   break;
           }
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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