Element.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.
 *
 *
 */
#ifndef _ELEMENTH
#define _ELEMENTH

#include <string>
#include <schemaparser/Constraint.h>

#define UNBOUNDED 1000
class Element
{
 public:
  Element(const std::string & name, 
          int type_id, 
          int min = 1, 
          int max = 1, 
          bool qualified = false, 
          std::string def = "", 
          std::string fixed ="");
  
  Element(void);

  void setType(int id);
  std::string getName() const;
  int getType() const;
  int max() const ;
  int min() const;
  std::string & defaultVal();
  std::string & fixedVal();
  bool isQualified() const;
  Element& operator = (const Element & e);
  void min(int m);
  void max(int m);
  //add a key/keyref/unique constraint
  void addConstraint(Constraint* c);
  Constraint* constraint();
  int nOccurrences;

 private:
  std::string elemName;
  std::string dval, fval;
  int elemType;
  bool bQualified;
  int minOccurs, maxOccurs;
  Constraint* cstr;
};

#ifdef LOGGING
ostream & operator << (ostream & stream, Element & e);
#endif

inline
Element::Element(const std::string & name, 
                 int type_id, 
                 int min , 
                 int max , 
                 bool qualified, 
                 std::string def , 
                 std::string fixed)
  : nOccurrences(0),
     elemName(name),
     dval(def),
     fval(fixed),
     elemType(type_id),
     bQualified(qualified),
     minOccurs(min),
     maxOccurs(max),
     cstr(0)
{
}

inline
Element::Element(void)
  :nOccurrences(0),
     elemType(0),
     bQualified (false),
     minOccurs (1),
     maxOccurs (1),
     cstr(0)
{
}

inline
void
Element::setType(int id)
{
  elemType = id;
}

inline
std::string
Element::getName() const
{
  return elemName;
}

inline
int
Element::getType() const
{
  return elemType;
}

inline
int
Element::max() const 
{
  return maxOccurs;
}
inline
int
Element::min() const
{
  return minOccurs;
}

inline
std::string &
Element::defaultVal()
{
  return dval;
}

inline
std::string &
Element::fixedVal()
{
  return fval;
}

inline
bool
Element::isQualified() const
{
  return bQualified;
}

inline
Element& 
Element::operator = (const Element & e)
{
  elemName = e.elemName;
  elemType = e.elemType;
  bQualified = e.isQualified();
  dval = e.dval;
  fval = e.fval;
  return *this;
  //min and max are not copied because they are specific to the
  //occurrence
}
inline
void
Element::min(int m)
{
  minOccurs=m;
}

inline
void 
Element::max(int m)
{
  maxOccurs=m;
}

inline
void
Element::addConstraint(Constraint* c)
{
  cstr=c;
}

inline
Constraint*
Element::constraint()
{
  return cstr;
}
#endif                                            /*  */

---