MappingElement.h

Go to the documentation of this file.

#ifndef INCLUDE_ORA_MAPPINGELEMENT_H
#define INCLUDE_ORA_MAPPINGELEMENT_H

//
#include <map>
#include <vector>
#include <string>
#include <memory>

namespace ora {

  class MappingElement
  {
  public:
    typedef enum { Undefined = -1,
                   Class,
                   Object,
                   Dependency,
                   Primitive,
                   Array,
                   CArray,
                   InlineCArray,
                   Pointer,
                   Reference,
                   OraReference,
                   OraPointer,
                   UniqueReference,
                   OraArray,
                   Blob,
                   NamedReference } ElementType;

    static std::string classMappingElementType();
    static std::string objectMappingElementType();
    static std::string dependencyMappingElementType();
    static std::string primitiveMappingElementType();
    static std::string arrayMappingElementType();
    static std::string CArrayMappingElementType();
    static std::string inlineCArrayMappingElementType();
    static std::string OraReferenceMappingElementType();
    static std::string OraPointerMappingElementType();
    static std::string uniqueReferenceMappingElementType();
    static std::string OraArrayMappingElementType();
    static std::string pointerMappingElementType();
    static std::string referenceMappingElementType();
    static std::string blobMappingElementType();
    static std::string namedReferenceMappingElementType();
    static bool isValidMappingElementType( const std::string& elementType );

    static std::string elementTypeAsString( ElementType elementType );

    static ElementType elementTypeFromString( const std::string& elementType );

    public:
    typedef std::map< std::string, MappingElement >::iterator iterator;
    typedef std::map< std::string, MappingElement >::const_iterator const_iterator;

    public:

    MappingElement();

    MappingElement( const std::string& elementType,
                    const std::string& variableName,
                    const std::string& variableType,
                    const std::string& tableName );

    // Copy constructor
    MappingElement( const MappingElement& element);

    // Assignment operator
    MappingElement& operator=(const MappingElement& element);

    ~MappingElement();

    ElementType elementType() const;

    std::string elementTypeString() const;

    bool isDependent() const;

    const MappingElement& parentClassMappingElement() const;
    
    const std::string& scopeName() const;
    const std::string& variableName() const;

    const std::string& variableNameForSchema() const;
    const std::string& variableType() const;

    const std::string& tableName() const;
    
    const std::vector< std::string >& columnNames() const;

    std::string idColumn() const;

    std::string pkColumn() const;

    std::vector<std::string> recordIdColumns() const;

    std::string posColumn() const;

    std::vector<std::pair<std::string,std::string> > tableHierarchy() const;
     
    void alterType( const std::string& elementType );
    
    void alterTableName( const std::string& tableName );

    void setColumnNames( const std::vector< std::string >& columns );

    iterator begin();
    const_iterator begin() const;

    iterator end();
    const_iterator end() const;

    iterator find( const std::string& key );
    const_iterator find( const std::string& key ) const;

    bool removeSubElement( const std::string& key );

    MappingElement& appendSubElement( const std::string& elementType,
                                      const std::string& variableName,
                                      const std::string& variableType,
                                      const std::string& tableName );

    /*
     * replace present data with the provided source
     */
    void override(const MappingElement& source);

    void printXML( std::ostream& outputStream, std::string indentation="" ) const;

  private:
    ElementType m_elementType;
    bool m_isDependentTree;    
    std::string m_scopeName;
    std::string m_variableName;
    std::string m_variableNameForSchema;
    std::string m_variableType;
    std::string m_tableName;
    std::vector<std::string> m_columnNames;
    
    std::map< std::string, MappingElement > m_subElements;

  };
}

inline 
ora::MappingElement::MappingElement():
  m_elementType(ora::MappingElement::Undefined),
  m_isDependentTree(false),
  m_scopeName(""),
  m_variableName(""),
  m_variableNameForSchema(""),
  m_variableType(""),
  m_tableName(""),
  m_columnNames(),
  m_subElements(){
}

inline 
ora::MappingElement::MappingElement( const MappingElement& element):
  m_elementType(element.m_elementType),
  m_isDependentTree(element.m_isDependentTree),
  m_scopeName(element.m_scopeName),
  m_variableName(element.m_variableName),
  m_variableNameForSchema(element.m_variableNameForSchema),
  m_variableType(element.m_variableType),
  m_tableName(element.m_tableName),
  m_columnNames(element.m_columnNames),
  m_subElements(element.m_subElements){
}

inline ora::MappingElement& 
ora::MappingElement::operator=(const MappingElement& element){
  if(this != &element){
     m_elementType = element.m_elementType;
     m_isDependentTree = element.m_isDependentTree;
     m_scopeName = element.m_scopeName;
     m_variableName = element.m_variableName;
     m_variableNameForSchema = element.m_variableNameForSchema;
     m_variableType = element.m_variableType;
     m_tableName = element.m_tableName;
     m_columnNames = element.m_columnNames;
     m_subElements = element.m_subElements;
  }
  return *this;
}


inline ora::MappingElement::iterator
ora::MappingElement::begin()
{
  return m_subElements.begin();
}

inline ora::MappingElement::const_iterator
ora::MappingElement::begin() const
{
  return m_subElements.begin();
}

inline ora::MappingElement::iterator
ora::MappingElement::end()
{
  return m_subElements.end();
}

inline ora::MappingElement::const_iterator
ora::MappingElement::end() const
{
  return m_subElements.end();
}

inline ora::MappingElement::iterator
ora::MappingElement::find( const std::string& key )
{
  return m_subElements.find( key );
}

inline ora::MappingElement::const_iterator
ora::MappingElement::find( const std::string& key ) const
{
  return m_subElements.find( key );
}

inline ora::MappingElement::ElementType
ora::MappingElement::elementType() const
{
  return m_elementType;
}

inline std::string
ora::MappingElement::elementTypeString() const
{
  return elementTypeAsString( m_elementType );
}

inline bool 
ora::MappingElement::isDependent() const {
  return m_isDependentTree;
}

inline const std::string&
ora::MappingElement::scopeName() const
{
  return m_scopeName;
}

inline const std::string&
ora::MappingElement::variableName() const
{
  return m_variableName;
}

inline const std::string&
ora::MappingElement::variableNameForSchema() const
{
  return m_variableNameForSchema;
}

inline const std::string&
ora::MappingElement::variableType() const
{
  return m_variableType;
}

inline const std::string&
ora::MappingElement::tableName() const
{
  return m_tableName;
}

inline const std::vector< std::string >&
ora::MappingElement::columnNames() const
{
  return m_columnNames;
}

#endif