BcfUtils.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _BCF_UTILS_H
#define _BCF_UTILS_H
 
#include "BcfCommon.h"
#include "StringArray.h"
 
#include <cstdint>
 
#include "BcfUnset.h"

class TiXmlElement;

namespace OdBcf {
 
  class OdBcfTimeStamp;
  typedef OdSmartPtr<OdBcfTimeStamp> OdBcfTimeStampPtr;
 
  class OdBcfElement;

  namespace Utils
  {

    bool parseBool(const OdString &value);

    const OdString& boolToString(bool value);

    BCF_EXPORT OdString formatDir(const OdString &dir);

    BCF_EXPORT int createDir(const OdString &dir);

    OdBcfTimeStampPtr getCurrentTime();

    bool validateNonEmptyString(const OdString &str);

    bool validateColorString(const OdString &str);

    OdResult createTextChild(TiXmlElement *pParent, const char *name, const char *value);
 
#define CREATE_TEXT_CHILD(pParent, Name, Value)                                        \
                                                                                       \
if(OdResult pParent##Res = OdBcf::Utils::createTextChild(pParent, Name, Value))        \
{                                                                                      \
  return pParent##Res;                                                                 \
}

    OdResult createConstructedChild(TiXmlElement *pParent, const char *name, const OdBcf::OdBcfElement *pValue);
 
#define CREATE_CONSTRUCTED_CHILD(pParent, Name, Value)                                 \
                                                                                       \
if(OdResult pParent##Res = OdBcf::Utils::createConstructedChild(pParent, Name, Value)) \
{                                                                                      \
  return pParent##Res;                                                                 \
}
 
#define VALIDATE_SIMPLE_FIELD(Field)                                                   \
                                                                                       \
if(OdBcf::Utils::isUnset(Field))                                                       \
{                                                                                      \
  return false;                                                                        \
}
 
#define VALIDATE_REQUIRED_NON_EMPTY_STRING_FIELD(Field)                                \
                                                                                       \
if(OdBcf::Utils::isUnset(Field) || !OdBcf::Utils::validateNonEmptyString(Field))       \
{                                                                                      \
  return false;                                                                        \
}
 
#define VALIDATE_UNREQUIRED_NON_EMPTY_STRING_FIELD(Field)                              \
                                                                                       \
if(!OdBcf::Utils::isUnset(Field))                                                      \
{                                                                                      \
  if(!OdBcf::Utils::validateNonEmptyString(Field))                                     \
  {                                                                                    \
    return false;                                                                      \
  }                                                                                    \
}
 
#define VALIDATE_UNREQUIRED_CONSTRUCTED_FIELD(Field)                                   \
                                                                                       \
if(!OdBcf::Utils::isUnset(Field))                                                      \
{                                                                                      \
  if(Field->validate() == false)                                                       \
  {                                                                                    \
    return false;                                                                      \
  }                                                                                    \
}
 
#define VALIDATE_REQUIRED_CONSTRUCTED_FIELD(Field)                                     \
                                                                                       \
if(!OdBcf::Utils::isUnset(Field))                                                      \
{                                                                                      \
  if(Field->validate() == false)                                                       \
  {                                                                                    \
    return false;                                                                      \
  }                                                                                    \
}                                                                                      \
else                                                                                   \
{                                                                                      \
  return false;                                                                        \
}
 
#define VALIDATE_UNREQUIRED_CONSTRUCTED_COLLECTION(Collection)                         \
                                                                                       \
for(const auto& element : Collection)                                                  \
{                                                                                      \
  VALIDATE_UNREQUIRED_CONSTRUCTED_FIELD(element);                                      \
}
 
#define VALIDATE_REQUIRED_CONSTRUCTED_COLLECTION(Collection)                           \
                                                                                       \
VALIDATE_UNREQUIRED_CONSTRUCTED_COLLECTION(Collection);                                \
if(Collection.size() == 0)                                                             \
{                                                                                      \
  return false;                                                                        \
}
 
  } //namespace Utils
 
} //namespace OdBcf
 
#endif // _BCF_UTILS_H