TypeContainer.h

Go to the documentation of this file.

/* 
 * wsdlpull - A C++ parser  for WSDL  (Web services description language)
 * Copyright (C) 2005-2007 Vivek Krishna
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

//This class is a recursive storage container for any xml data type
//It stores the actual values occuring in an XML Schema Instance ,
//for a given type defined in the SchemaParser

#ifndef _TYPECONTAINERH
#define  _TYPECONTAINERH
#include <map>

#include <xmlpull/XmlUtils.h>
#include <schemaparser/SchemaParser.h>

class TypeContainer;


typedef struct
{
  std::vector<TypeContainer *>tc;
  int count;//Count maintains the last accessed container
  int num;//num is the number of occurrences of this child
} Containers;

class TypeContainer
{
 public:
  TypeContainer(int  typeId,const SchemaParser * sp);
  TypeContainer::TypeContainer(ContentModel* cm,
                               const SchemaParser * sp);
  ~TypeContainer();
  TypeContainer *getAttributeContainer(string attName, 
                                       bool create=false);
  TypeContainer *getBaseTypeContainer(bool create=false);

  TypeContainer *getChildContainer(string elemName, 
                                   bool create = false);

  TypeContainer * getChildContainer(ContentModel* cm,
                                    bool create=false);

  //If this is a container for simple type this method 
  //returns a void* to the type .The actual type  must be found using getTypeId()
  void *getValue();
  //This method searches the xml instance for an element whose name is specified
  //and is a simple type.If the return value is non null then type has the actual
  //type of the returned value which can be used for type casting
  void * getValue(const std::string & name,Schema::Type & type);

  const SchemaParser * schemaParser()const;
  bool isValueValid()const;
  //return the type which the container instanciates
  //The typeId is 0 if this is a container for an anonymous content model
  int getTypeId()const;
  //return the content model which the container instanciates
  //The content model is null if this is a container instanciates a schema defined type
  ContentModel* getContentModel()const;

  //Various set methods
  void setValue(const std::string & sValue,bool valid=true);
  void setValue(int iValue,bool valid=true);
  void setValue(char  cValue,bool valid=true);
  void setValue(long lValue,bool valid=true);
  void setValue(unsigned long ulValue,bool valid=true);
  void setValue(float fValue,bool valid=true);
  void setValue(double dbValue,bool valid=true);
  void setValue(bool bValue,bool valid=true);
  void setValue(Qname & qnValue,bool valid=true);

  //if the container actually stores atomic data,return its type
  void setValAsString(const std::string &v);//set a value without validating
  void print(ostream & os); 
  friend  ostream &operator<<(ostream &os, TypeContainer &tc);

 private:
  //The unique id of the type for which this holds data
  Schema::Type typeId_; 
  ContentModel* cm_;
  map < string, Containers *> particleContainers_;//Type containers for particles
  map<ContentModel*,TypeContainer* >cmContainers_;//Type container for the content models
  map < string, TypeContainer *> attributeContainers_;//TypeContainers for attributes
  const SchemaParser *sParser_;
  TypeContainer * baseContainer_;

  union
  {
    string *sValue;
    int *iValue;
    unsigned int *uiValue;
    long *lValue;
    unsigned long *ulValue;
    short *shValue;
    unsigned short *usValue;
    float *fValue;
    double *dbValue;
    bool *bValue;
    char *cValue;

    //              Date *dValue;
    //              DateTime *dtValue;
    //              Time *tValue;
    Qname *qnValue;

    //      Uri *uriValue ;
  } Value;
  bool isValueValid_;//is the atomic date type valid
  std::string strVal;
  vector<TypeContainer*> tcTable;

  void deleteValue();
  void printComplexType (std::ostream & os);
  void printSimpleType (std::ostream & os);
  void printContentModel(std::ostream & os);
};

inline
void
TypeContainer::setValue(const std::string & sValue,bool valid)
{
  Value.sValue = new string(sValue);
  isValueValid_=valid;
}

inline
void
TypeContainer::setValue(int iValue,bool valid)
{
  Value.iValue = new int (iValue);
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(char cValue,bool valid)
{
  Value.cValue = new char (cValue);
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(long lValue,bool valid)
{
  Value.lValue = new long (lValue);
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(unsigned long ulValue,bool valid)
{
  Value.ulValue = new unsigned long (ulValue);
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(float fValue,bool valid)
{
  Value.fValue = new float;
  *(Value.fValue) = fValue;
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(double dbValue,bool valid)
{
  Value.dbValue = new double;
  *(Value.dbValue) = dbValue;
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(bool bValue,bool valid)
{
  Value.bValue = new bool;
  *(Value.bValue) = bValue;
  isValueValid_=valid;
}

inline
void 
TypeContainer::setValue(Qname & qnValue,bool valid)
{
  Value.qnValue = new Qname(qnValue);
  isValueValid_=valid;
}

inline
int 
TypeContainer::getTypeId()const
{
  return typeId_;
}

inline 
ContentModel* 
TypeContainer::getContentModel()const
{
  return cm_;
}

inline
void
TypeContainer::setValAsString(const std::string&v)
{
  strVal=v;
}
/*
inline
void
TypeContainer::setValidity(bool b )
{
  isValueValid_ = b;
}
*/


inline
bool
TypeContainer::isValueValid()const
{
  return isValueValid_;
}

#endif                                            /*  */

---