/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#if !defined(ODA_ODMVDXMLCOMMON_H_INCLUDED_)
#define ODA_ODMVDXMLCOMMON_H_INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "OdaCommon.h"
#include "IfcCommon.h"
#include "RxObject.h"
#include "RxObjectImpl.h"
#include "OdArray.h"
#include "OdAnsiString.h"

// Generate error if item more than one.
// #define MORE_THAN_ONE_ERROR

#ifdef MVDXM_MORE_THAN_ONE_ERROR
#define MVDXM_MORE_THAN_ONE(parent, text, caption) appendXmlErrorMessage(parent, text, caption); return eSyntaxError;
#else
#define MVDXM_MORE_THAN_ONE(parent, text, caption) appendXmlWarningMessage(parent, text, caption)
#endif

#define RETURNNOTOK(expr) {OdResult odResult;if ((odResult=expr)) return odResult;};
#define RETURNNOTCHECK(expr) {OdResult odResult;if ((odResult=expr)) return odResult;};

/** \details 
Contains declarations related to Model View Definition (MVD) functionality.
*/
namespace OdMvdXml
{
  /** \details 
  Contains declarations of statuses of an element of model view definition element.
  */
  enum OdMvdStatus
  {
    /**The status value is not set.*/
    OdMvdStatusUnset = -1,
    /**The definition element is a sample.*/
    OdMvdSample = 0,
    /**The definition element is a proposal.*/
    OdMvdProposal,
    /**The definition element is a draft.*/
    OdMvdDraft,
    /**The definition element is a candidate.*/
    OdMvdCandidate,
    /**The definition element is final.*/
    OdMvdFinal,
    /**The definition element is deprecated.*/
    OdMvdDeprecated
  };

  /** \details 
  A class that implements a logical operator functionality.
  */
  class OdMvdOperator
  {
  public:
    /** \details 
    Logical operations supported by the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator.html">OdMvdOperator</exref> class.
    */
    enum Operator
    {
      /**Operation is not set.*/
      kUnset = -1,
      
      /**Logical AND operation: 
      <table>
        <tr><th>X</th><th>Y</th><th>X AND Y</th></tr>
        <tr><td>0</td><td>0</td><td>0</td></tr>
        <tr><td>0</td><td>1</td><td>0</td></tr>
        <tr><td>1</td><td>0</td><td>0</td></tr>
        <tr><td>1</td><td>1</td><td>1</td></tr>
      </table>
      */
      kAND = 0,
      
      /**Logical OR operation:
      <table>
        <tr><th>X</th><th>Y</th><th>X OR Y</th></tr>
        <tr><td>0</td><td>0</td><td>0</td></tr>
        <tr><td>0</td><td>1</td><td>1</td></tr>
        <tr><td>1</td><td>0</td><td>1</td></tr>
        <tr><td>1</td><td>1</td><td>1</td></tr>
      </table>
      */
      kOR,
      
      /**Logical NOT operation.
      <table>
        <tr><th>X</th><th>NOT X</th></tr>
        <tr><td>0</td><td>1</td></tr>
        <tr><td>1</td><td>0</td></tr>
      </table>
      */
      kNOT,
      
      /**Logical NAND operation.
      <table>
        <tr><th>X</th><th>Y</th><th>X NAND Y</th></tr>
        <tr><td>0</td><td>0</td><td>1</td></tr>
        <tr><td>0</td><td>1</td><td>1</td></tr>
        <tr><td>1</td><td>0</td><td>1</td></tr>
        <tr><td>1</td><td>1</td><td>0</td></tr>
      </table>
      */
      kNAND,
      
      /**Logical NOR operation.
      <table>
        <tr><th>X</th><th>Y</th><th>X NOR Y</th></tr>
        <tr><td>0</td><td>0</td><td>1</td></tr>
        <tr><td>0</td><td>1</td><td>0</td></tr>
        <tr><td>1</td><td>0</td><td>0</td></tr>
        <tr><td>1</td><td>1</td><td>0</td></tr>
      </table>
      */
      kNOR,
      
      /**Logical XOR operation.
      <table>
        <tr><th>X</th><th>Y</th><th>X XOR Y</th></tr>
        <tr><td>0</td><td>0</td><td>0</td></tr>
        <tr><td>0</td><td>1</td><td>1</td></tr>
        <tr><td>1</td><td>0</td><td>1</td></tr>
        <tr><td>1</td><td>1</td><td>0</td></tr>
      </table>
      */
      kXOR,
      
      /**Logical NXOR operation.
      <table>
        <tr><th>X</th><th>Y</th><th>X NXOR Y</th></tr>
        <tr><td>0</td><td>0</td><td>1</td></tr>
        <tr><td>0</td><td>1</td><td>0</td></tr>
        <tr><td>1</td><td>0</td><td>0</td></tr>
        <tr><td>1</td><td>1</td><td>1</td></tr>
      </table>
      */
      kNXOR
    };
    
    /** \details 
    Creates a new operator object with unset operation.
    */
    OdMvdOperator()
      :m_operator(kUnset)
    {
    }
    
    /** \details
    Retrieves the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">operation</exref> associated with the operator object.
    \returns A value of the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdOperator__Operator.html">OdMvdOperator::Operator enumeration</exref> that represents the logical operation performed by the operator object.
    */
    const Operator get() const
    {
      return m_operator;
    }
    
    /** \details 
    Checks whether the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">operation</exref> that the operator performs is not set.
    \returns true if the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">operation</exref> is NOT specified; otherwise, the method returns false.
    */
    const bool IsUnset() const
    {
      return (m_operator == kUnset);
    }
    
    /** \details 
    Performs the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref> associated with the operator object.
    \param first  [in] The value of the first operand of the operation.
    \param second [in] The value of the second operand of the operation.
    \returns A boolean value that contains the result of the operation.
    */
    const bool performBoolean(const bool first, const bool second) const
    {
      switch (m_operator) {
      case kAND:  return first && second;
      case kOR:   return first || second;
      case kNOT:  return !first;
      case kNAND: return !(first && second);
      case kNOR:  return !(first || second);
      case kXOR:  return first != second;
      case kNXOR: return first == second;
      default: return false;
      }
    }
    
    /** \details 
    Retrieves the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref> associated with the operator object.
    \returns An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdOperator__Operator.html">logical operation</exref>.
    */
    OdAnsiString toString()
    {
      switch (m_operator) {
      case kAND:  return "AND";
      case kOR:   return "OR";
      case kNOT:  return "NOT";
      case kNAND: return "NAND";
      case kNOR:  return "NOR";
      case kXOR:  return "XOR";
      case kNXOR: return "NXOR";
      default: return "";
      }
    }
    
    /** \details 
    The equality operator that compares two MVD operator objects.
    \param other [in] An operator object to be compared with (right-hand operand of the comparison operation).
    \returns true if the operator object equals to another specified operator object; otherwise, the result equals to the false value.  
    */
    bool operator==(const OdMvdOperator& other) const
    {
      return (*this).m_operator == other.m_operator;
    }

    /** \details 
    The equality operator that checks whether the MVD operator object performs a specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref>.
    \param other [in] An <exref target="../tifc_api_cpp/OdMvdXml::OdMvdOperator__Operator.html">Operator enumeration</exref> value that contains the logical operation.
    \returns true if the operator object performs the specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref>; otherwise, the result equals to the false value.
    */
    bool operator==(const Operator other) const
    {
      return (*this).m_operator == other;
    }
    
    /** \details 
    The assignment operator for operator objects.
    \param other [in] Another operator object to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the operator object modified by the assignment operation.
    */
    OdMvdOperator& operator=(const OdMvdOperator& other)
    {
      m_operator = other.m_operator;
      return (*this);
    }
    
    /** \details 
    The assignment operator for operator objects.
    \param other [in] An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the operator object modified by the assignment operation.
    */
    OdMvdOperator& operator=(const OdAnsiString& other)
    {
      return (*this) = other.c_str();
    }

    /** \details 
    The assignment operator for operator objects.
    \param other [in] An ANSI string that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdOperator__Operator.html">logical operation</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the operator object modified by the assignment operation.
    */
    OdMvdOperator& operator=(const char* other)
    {
      m_operator = kUnset;
      if (other)
      {
        OdAnsiString str(other);
        str.makeUpper();
        if (str.iCompare("AND") == 0)
          m_operator = kAND;
        else if (str.iCompare("OR") == 0)
          m_operator = kOR;
        else if (str.iCompare("NOT") == 0)
          m_operator = kNOT;
        else if (str.iCompare("NAND") == 0)
          m_operator = kNAND;
        else if (str.iCompare("NOR") == 0)
          m_operator = kNOR;
        else if (str.iCompare("XOR") == 0)
          m_operator = kXOR;
        else if (str.iCompare("NXOR") == 0)
          m_operator = kNXOR;
      }
      return (*this);
    }

  private:
    Operator m_operator;
  };

  /** \details 
  A class that stores and operates the data about applicability within the Exchange Requirement Model (ERM). 
  */
  class OdMvdApplicability
  {
  public:
    
    /** \details 
    Declarations that cover applicability values. 
    */
    enum Applicability
    {
      /**Applicability is not set.*/
      kUnset = -1,
      
      /**Import applicability that assumes the definition of data that the importing application can correctly process.*/
      kImport = 0,
      
      /**Export applicability that assumes the exchange application must create a data that matches the defined requirements.*/
      kExport,
      
      /**Applicable for both import and export.*/
      kBoth
    };

    /** \details 
    Creates a new applicability object with unset <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability value</exref>.
    */
    OdMvdApplicability()
      : m_applicability(kUnset)
    {}
    
    /** \details
    Retrieves the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdApplicability__Applicability.html">applicability type</exref> associated with the applicability object.
    \returns A value of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">OdMvdApplicability::Applicability enumeration</exref> that represents the applicability type.
    */
    const Applicability get() const
    {
      return m_applicability;
    }
    
    /** \details 
    Checks whether the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability value</exref> is not set.
    \returns true if the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability value</exref> is NOT specified; otherwise, the method returns false.
    */
    const bool IsUnset() const
    {
      return (m_applicability == kUnset);
    }
    
    /** \details 
    Retrieves the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability value</exref> associated with the applicability object.
    \returns An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability type</exref>
    */
    OdAnsiString toString()
    {
      switch (m_applicability) {
      case kImport: return "import";
      case kExport: return "export";
      case kBoth:   return "both";
      default: return "";
      }
    }
    
    /** \details 
    The equality operator that compares two applicability objects.
    \param other [in] An applicability object to be compared with (right-hand operand of the comparison operation).
    \returns true if the applicability object equals to another specified applicability object; otherwise, the result equals to the false value.  
    */
    bool operator==(const OdMvdApplicability& other) const
    {
      return (*this).m_applicability == other.m_applicability;
    }
    
    /** \details 
    The equality operator that checks whether the applicability object has a specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability type</exref>.
    \param other [in] An <exref target="../tifc_api_cpp/OdMvdXml::OdMvdApplicability__Applicability.html">OdMvdApplicability::Applicability enumeration</exref> value that contains the applicability type.
    \returns true if the applicability object has the specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability type</exref>; otherwise, the result equals to the false value.
    */
    bool operator==(const Applicability other) const
    {
      return (*this).m_applicability == other;
    }
    
    /** \details 
    The assignment operator for applicability objects.
    \param other [in] Another applicability object to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the applicability object modified by the assignment operation.
    */
    OdMvdApplicability& operator=(const OdMvdApplicability& other)
    {
      m_applicability = other.m_applicability;
      return (*this);
    }
    
    /** \details 
    The assignment operator for applicability objects.
    \param other [in] An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdApplicability__Applicability.html">applicability type</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the applicability object modified by the assignment operation.
    */
    OdMvdApplicability& operator=(const OdAnsiString& other)
    {
      return (*this) = other.c_str();
    }
    
    /** \details 
    The assignment operator for applicability objects.
    \param other [in] A ANSI string that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdApplicability__Applicability.html">applicability type</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the applicability object modified by the assignment operation.
    */
    OdMvdApplicability& operator=(const char* other)
    {
      m_applicability = kUnset;
      if (other)
      {
        OdAnsiString str(other);
        str.makeLower();
        if (str.iCompare("import") == 0)
          m_applicability = kImport;
        else if (str.iCompare("export") == 0)
          m_applicability = kExport;
        else if (str.iCompare("both") == 0)
          m_applicability = kBoth;
      }
      return (*this);
    }

  private:
    Applicability m_applicability;
  };

  /** \details 
  A class that implements storing and operating of exchange requirements.  
  */
  class OdMvdRequirement
  {
  public:
    /** \details 
    Declarations of exchange requirement types.
    */
    enum Requirement
    {
      /**An exchange requirement is undefined.*/
      kUnset = -1,
      
      /**A mandatory requirement: must be  met; otherwise an error occurs.*/
      kMandatory = 0,
      
      /**A recommended requirement: should be met; otherwise a warning occurs.*/
      kRecommended,
      
      /**A not-relevant requirement: no requirements to meet.*/
      kNotRelevant,
      
      /**A not-recommended requirement: should NOT be met; otherwise a warning occurs.*/
      kNotRecommended,
      
      /**An excluded requirement: must NOT be true; otherwise an error occurs.*/
      kExcluded
    };
    
    /** \details 
    Creates a new requirement object. 
    */
    OdMvdRequirement()
      : m_requirement(kUnset)
    {}
    
    /** \details
    Retrieves the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdRequirement__Requirement.html">requirement type</exref> associated with the requirement object.
    \returns A value of the <exref target="../tifc_api_cpp/OdMvdXml::OdMvdRequirement__Requirement.html">OdMvdRequirement::Requirement enumeration</exref> that represents the requirement type.
    */
    const Requirement get() const
    {
      return m_requirement;
    }
    
    /** \details 
    Checks whether the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref> is not set.
    \returns true if the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref> is NOT specified; otherwise, the method returns false.
    */
    const bool IsUnset() const
    {
      return (m_requirement == kUnset);
    }
    
    /** \details 
    Retrieves the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref> associated with the requirement object.
    \returns An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains the textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref>.
    */
    OdAnsiString toString()
    {
      switch (m_requirement) {
      case kMandatory:      return "mandatory";
      case kRecommended:    return "recommended";
      case kNotRelevant:    return "not-relevant";
      case kNotRecommended: return "not-recommended";
      case kExcluded:       return "excluded";
      default: return "";
      }
    }
    
    /** \details 
    The equality operator that compares two requirement objects.
    \param other [in] A requirement object to be compared with (right-hand operand of the comparison operation).
    \returns true if the requirement object equals to another specified requirement object; otherwise, the result equals to the false value.  
    */
    bool operator==(const OdMvdRequirement& other) const
    {
      return (*this).m_requirement == other.m_requirement;
    }

    /** \details 
    The equality operator that checks whether the requirement object has a specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref>.
    \param other [in] An <exref target="../tifc_api_cpp/OdMvdXml::OdMvdRequirement__Requirement.html">OdMvdRequirement::Requirement enumeration</exref> value that contains the requirement type.
    \returns true if the requirement object has the specified <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref>; otherwise, the result equals to the false value.
    */    
    bool operator==(const Requirement other) const
    {
      return (*this).m_requirement == other;
    }
    
    /** \details 
    The assignment operator for requirement objects.
    \param other [in] Another requirement object to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the requirement object modified by the assignment operation.
    */
    OdMvdRequirement& operator=(const OdMvdRequirement& other)
    {
      m_requirement = other.m_requirement;
      return (*this);
    }
    
    /** \details 
    The assignment operator for requirement objects.
    \param other [in] An <exref target="../tkernel_api_cpp/OdAnsiString.html">ANSI string</exref> that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the requirement object modified by the assignment operation.
    */
    OdMvdRequirement& operator=(const OdAnsiString& other)
    {
      return (*this) = other.c_str();
    }

    /** \details 
    The assignment operator for requirement objects.
    \param other [in] A ANSI string that contains a textual representation of the <exref target="../tifc_api_cpp/OdMvdXml__OdMvdRequirement__Requirement.html">requirement type</exref> to be assigned (right-hand operand of the assignment operation).
    \returns A reference to the requirement object modified by the assignment operation.
    */    
    OdMvdRequirement& operator=(const char* other)
    {
      m_requirement = kUnset;
      if (other)
      {
        OdAnsiString str(other);
        str.makeLower();
        if (str.iCompare("mandatory") == 0)
          m_requirement = kMandatory;
        else if (str.iCompare("recommended") == 0)
          m_requirement = kRecommended;
        else if ((str.iCompare("not-relevant") == 0) || (str.iCompare("not relevant") == 0))
          m_requirement = kNotRelevant;
        else if ((str.iCompare("not-recommended") == 0) || (str.iCompare("not recommended") == 0))
          m_requirement = kNotRecommended;
        else if (str.iCompare("excluded") == 0)
          m_requirement = kExcluded;
      }
      return (*this);
    }
  private:
    Requirement m_requirement;
  };
} // namespace OdMvdXml

#endif // !defined(ODA_ODMVDXMLCOMMON_H_INCLUDED_)