sexpression.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBREPCB_CORE_SEXPRESSION_H
#define LIBREPCB_CORE_SEXPRESSION_H
 
/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../fileio/filepath.h"
 
#include <QtCore>
 
#include <memory>
#include <vector>
 
/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {
 
class SExpression;
 
template <typename T>
std::unique_ptr<SExpression> serialize(const T& obj);
 
template <typename T>
T deserialize(const SExpression& node);
 
/*******************************************************************************
 *  Class SExpression
 ******************************************************************************/
 
class SExpression final {
  Q_DECLARE_TR_FUNCTIONS(SExpression)
 
public:
  // Types
  enum class Mode {
    LibrePCB,  
    Permissive,  
  };
  enum class Type {
    List,  
    Token,  
    String,  
    LineBreak,  
  };
 
  // Constructors / Destructor
  SExpression() noexcept;
  SExpression(const SExpression& other) noexcept;
  ~SExpression() noexcept;
 
  // Getters
  const FilePath& getFilePath() const noexcept { return mFilePath; }
  Type getType() const noexcept { return mType; }
  bool isList() const noexcept { return mType == Type::List; }
  bool isToken() const noexcept { return mType == Type::Token; }
  bool isString() const noexcept { return mType == Type::String; }
  bool isLineBreak() const noexcept { return mType == Type::LineBreak; }
  const QString& getName() const;
  const QString& getValue() const;
  std::size_t getChildCount() const noexcept { return mChildren.size(); }
  bool containsChild(const SExpression& child) const noexcept;
  SExpression& getChild(int index);
  const SExpression& getChild(int index) const;
  QList<SExpression*> getChildren(Type type) noexcept;
  QList<const SExpression*> getChildren(Type type) const noexcept;
  QList<SExpression*> getChildren(const QString& name) noexcept;
  QList<const SExpression*> getChildren(const QString& name) const noexcept;
 
  SExpression& getChild(const QString& path);
  const SExpression& getChild(const QString& path) const;
 
  SExpression* tryGetChild(const QString& path) noexcept;
  const SExpression* tryGetChild(const QString& path) const noexcept;
 
  // Setters
  void setName(const QString& name);
  void setValue(const QString& value);
 
  // General Methods
  void ensureLineBreak();
  SExpression& appendList(const QString& name);
  void appendChild(std::unique_ptr<SExpression> child);
  template <typename T>
  SExpression& appendChild(const T& obj) {
    appendChild(serialize(obj));
    return *mChildren.back();
  }
  void appendChild(const QString& child, std::unique_ptr<SExpression> obj) {
    Q_ASSERT(obj);
    appendList(child).appendChild(std::move(obj));
  }
  template <typename T>
  SExpression& appendChild(const QString& child, const T& obj) {
    appendChild(child, serialize(obj));
    return *mChildren.back();
  }
  void removeChild(const SExpression& child);
  void removeChildrenWithNodeRecursive(const SExpression& search) noexcept;
  void replaceRecursive(const SExpression& search,
                        const SExpression& replace) noexcept;
  QByteArray toByteArray(Mode mode = Mode::LibrePCB) const;
 
  // Operator Overloadings
  bool operator==(const SExpression& rhs) const noexcept;
  bool operator!=(const SExpression& rhs) const noexcept {
    return !(*this == rhs);
  }
  bool operator<(const SExpression& rhs) const noexcept;
  SExpression& operator=(const SExpression& rhs) noexcept;
 
  // Static Methods
  static std::unique_ptr<SExpression> createList(const QString& name);
  static std::unique_ptr<SExpression> createToken(const QString& token);
  static std::unique_ptr<SExpression> createString(const QString& string);
  static std::unique_ptr<SExpression> createLineBreak();
  static std::unique_ptr<SExpression> parse(const QByteArray& content,
                                            const FilePath& filePath,
                                            Mode mode = Mode::LibrePCB);
 
private:  // Methods
  SExpression(Type type, const QString& value);
 
  bool isMultiLine() const noexcept;
  static bool skipLineBreaks(
      const std::vector<std::unique_ptr<SExpression>>& children,
      int& index) noexcept;
  static std::unique_ptr<SExpression> parse(const QString& content, int& index,
                                            const FilePath& filePath,
                                            Mode mode);
  static std::unique_ptr<SExpression> parseList(const QString& content,
                                                int& index,
                                                const FilePath& filePath,
                                                Mode mode);
  static QString parseToken(const QString& content, int& index,
                            const FilePath& filePath, Mode mode);
  static QString parseString(const QString& content, int& index,
                             const FilePath& filePath);
  static void skipWhitespaceAndComments(const QString& content, int& index,
                                        bool skipNewline = false);
  static QString escapeString(const QString& string) noexcept;
  static bool isValidToken(const QString& token, Mode mode) noexcept;
  static bool isValidTokenChar(const QChar& c, Mode mode) noexcept;
  QString toString(int indent, Mode mode) const;
 
private:  // Data
  Type mType;
  QString mValue;  
  // Note: For memory-safe removal operations we don't use a Qt container class!
  std::vector<std::unique_ptr<SExpression>> mChildren;
  FilePath mFilePath;
 
  // qHash() needs access to mChildrenNew.
  friend uint qHash(const SExpression& node, uint seed) noexcept;
};
 
/*******************************************************************************
 *  Non-Member Functions
 ******************************************************************************/
 
uint qHash(const SExpression& node, uint seed = 0) noexcept;
uint qHash(const std::unique_ptr<SExpression>& ptr, uint seed = 0) noexcept;
 
/*******************************************************************************
 *  End of File
 ******************************************************************************/
 
}  // namespace librepcb
 
#endif