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>

/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {

class SExpression;

template <typename T>
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 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;
  const QList<SExpression>& getChildren() const noexcept { return mChildren; }
  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);
  SExpression& appendChild(const SExpression& child);
  template <typename T>
  SExpression& appendChild(const T& obj) {
    appendChild(serialize(obj));
    return *this;
  }
  template <typename T>
  SExpression& appendChild(const QString& child, const T& obj) {
    return appendList(child).appendChild(obj);
  }
  void removeChild(const SExpression& child);
  void removeChildrenWithNodeRecursive(const SExpression& search) noexcept;
  void replaceRecursive(const SExpression& search,
                        const SExpression& replace) noexcept;
  QByteArray toByteArray() 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 SExpression createList(const QString& name);
  static SExpression createToken(const QString& token);
  static SExpression createString(const QString& string);
  static SExpression createLineBreak();
  static SExpression parse(const QByteArray& content, const FilePath& filePath);

private:  // Methods
  SExpression(Type type, const QString& value);

  bool isMultiLine() const noexcept;
  static bool skipLineBreaks(const QList<SExpression>& children,
                             int& index) noexcept;
  static SExpression parse(const QString& content, int& index,
                           const FilePath& filePath);
  static SExpression parseList(const QString& content, int& index,
                               const FilePath& filePath);
  static QString parseToken(const QString& content, int& index,
                            const FilePath& filePath);
  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) noexcept;
  static bool isValidTokenChar(const QChar& c) noexcept;
  QString toString(int indent) const;

private:  // Data
  Type mType;
  QString mValue;  
  QList<SExpression> mChildren;
  FilePath mFilePath;
};

/*******************************************************************************
 *  Non-Member Functions
 ******************************************************************************/

inline uint qHash(const SExpression& node, uint seed = 0) noexcept {
  switch (node.getType()) {
    case SExpression::Type::LineBreak:
      return ::qHash(static_cast<int>(node.getType()), seed);
    case SExpression::Type::String:
    case SExpression::Type::Token:
      return ::qHash(
          qMakePair(static_cast<int>(node.getType()), node.getValue()), seed);
    case SExpression::Type::List: {
      const QList<SExpression>& children = node.getChildren();
      return ::qHashRange(children.begin(), children.end(), seed);
    }
    default:
      Q_ASSERT(false);
      return 0;
  }
}

/*******************************************************************************
 *  End of File
 ******************************************************************************/

}  // namespace librepcb

#endif