libwz 0.1.0

package/include/wz/WzImage.h

@@ -0,0 +1,97 @@
+#ifndef WZ_WZIMAGE_H_
+#define WZ_WZIMAGE_H_
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+#include "wz/Util/Defines.h"
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzStream.h"
+#include "wz/WzImageProperty.h"
+#include "wz/WzObject.h"
+#include "wz/WzPropertyCollection.h"
+
+namespace wz {
+
+class WzImage final : public WzObject, public IPropertyContainer {
+ public:
+  static constexpr int WzImageHeaderByte_WithoutOffset = 0x73;
+  static constexpr int WzImageHeaderByte_WithOffset = 0x1B;
+
+  WzImage();
+  explicit WzImage(const std::string& name);
+  WzImage(const std::string& name, WzBinaryReader& reader, int checksum);
+  WzImage(const std::string& name,
+          WzFileStream&& dataStream,
+          WzMapleVersion mapleVersion);
+  ~WzImage() override;
+
+  WZ_DISALLOW_COPY_AND_MOVE(WzImage)
+
+  WzObjectType ObjectType() const override;
+  WzFile* WzFileParent() const override;
+  Result<std::unique_ptr<WzObject>> Remove() override;
+
+  bool Parsed() const { return parsed_; }
+  void SetParsed(bool v) { parsed_ = v; }
+  bool Changed() const { return is_image_changed_; }
+  void SetChanged(bool v) { is_image_changed_ = v; }
+  int BlockSize() const { return size_; }
+  void SetBlockSize(int v) { size_ = v; }
+  int Checksum() const { return checksum_; }
+  int64_t Offset() const { return offset_; }
+  void SetOffset(int64_t v) { offset_ = v; }
+  int BlockStart() const { return blockStart_; }
+  int64_t TempFileStart() const { return tempFileStart_; }
+  void SetTempFileStart(int64_t v) { tempFileStart_ = v; }
+  int64_t TempFileEnd() const { return tempFileEnd_; }
+  void SetTempFileEnd(int64_t v) { tempFileEnd_ = v; }
+  bool ParseEverything() const { return parseEverything_; }
+  void SetParseEverything(bool v) { parseEverything_ = v; }
+  bool IsLuaWzImage() const;
+
+  using IPropertyContainer::AddProperty;
+  WzPropertyCollection* WzProperties() override;
+  Result<WzPropertyCollection*> WzPropertiesResult();
+  Result<void> AddProperty(WzImageProperty* prop) override;
+  Result<void> AddProperty(std::unique_ptr<WzImageProperty> prop) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      const std::string& propertyName) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop) override;
+  Result<void> ClearProperties() override;
+
+  WzImageProperty* GetFromPath(const std::string& path);
+  Result<WzImageProperty*> GetFromPathResult(const std::string& path);
+  Result<bool> ParseImage(bool forceReadFromData = false);
+
+  WzImageProperty* operator[](const std::string& name);
+  Result<WzImageProperty*> GetPropertyByName(const std::string& name);
+  Result<void> SaveImage(WzBinaryWriter* writer,
+                         bool isDefaultUserKey = true,
+                         bool forceReadFromData = false);
+  void CalculateAndSetImageChecksum(const std::vector<uint8_t>& bytes);
+  void UnparseImage();
+
+  WzBinaryReader* Reader() const { return reader_; }
+
+ private:
+  Result<void> EnsureParsed();
+
+  bool parsed_ = false;
+  bool is_image_changed_ = false;
+  int size_ = 0;
+  int checksum_ = 0;
+  int64_t offset_ = 0;
+  int64_t tempFileStart_ = 0;
+  int64_t tempFileEnd_ = 0;
+  int blockStart_ = 0;
+  bool parseEverything_ = false;
+  WzFileStream dataStream_;
+  std::optional<WzBinaryReader> ownedReader_;
+  WzBinaryReader* reader_ = nullptr;
+  WzPropertyCollection properties_;
+};
+
+}  // namespace wz
+#endif  // WZ_WZIMAGE_H_

package/include/wz/WzImageProperty.h

@@ -0,0 +1,92 @@
+#ifndef WZ_WZIMAGEPROPERTY_H_
+#define WZ_WZIMAGEPROPERTY_H_
+#include <concepts>
+#include <memory>
+#include <string>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/Util/Defines.h"
+#include "wz/WzEnums.h"
+#include "wz/WzObject.h"
+#include "wz/WzPropertyCollection.h"
+
+namespace wz {
+
+class WzBinaryReader;
+class WzBinaryWriter;
+class WzImage;
+class WzFile;
+class WzImageProperty;
+
+class IPropertyContainer {
+ public:
+  virtual ~IPropertyContainer() = default;
+  virtual Result<void> AddProperty(WzImageProperty* prop) = 0;
+  virtual Result<void> AddProperty(
+      std::unique_ptr<WzImageProperty> prop) = 0;
+  template <typename T>
+    requires std::derived_from<T, WzImageProperty>
+  Result<void> AddProperty(std::unique_ptr<T> prop) {
+    return AddProperty(std::unique_ptr<WzImageProperty>(std::move(prop)));
+  }
+  virtual Result<void> AddProperties(WzPropertyCollection& props);
+  virtual Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      const std::string& propertyName) = 0;
+  virtual Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop) = 0;
+  virtual Result<void> ClearProperties() = 0;
+  virtual WzPropertyCollection* WzProperties() = 0;
+};
+
+class WzImageProperty : public WzObject {
+ public:
+  WzImageProperty() = default;
+  WZ_DISALLOW_COPY_AND_MOVE(WzImageProperty)
+
+  WzObjectType ObjectType() const override { return WzObjectType::Property; }
+  WzFile* WzFileParent() const override;
+  Result<std::unique_ptr<WzObject>> Remove() override;
+
+  virtual WzPropertyType PropertyType() const = 0;
+  virtual bool IsRawDataProperty() const { return false; }
+  virtual bool IsVideoProperty() const { return false; }
+  virtual WzPropertyCollection* WzProperties() { return nullptr; }
+  Result<void> AddProperty(WzImageProperty* prop);
+  Result<void> AddProperty(std::unique_ptr<WzImageProperty> prop);
+  // Detaches prop from this container and returns ownership to the caller.
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop);
+  Result<void> ClearProperties();
+  virtual Result<void> WriteValue(WzBinaryWriter* writer) const;
+
+  virtual WzImageProperty* operator[](const std::string& name);
+
+  virtual WzImageProperty* GetFromPath(const std::string& path);
+  WzImageProperty* GetLinkedWzImageProperty();
+
+  WzImage* ParentImage() const;
+  void MarkParentImageChanged() const;
+
+  virtual void SetValue(const std::string& value);
+  virtual void SetValue(int32_t value);
+  virtual void SetValue(int64_t value);
+  virtual void SetValue(float value);
+  virtual void SetValue(double value);
+  virtual void SetValue(const std::vector<uint8_t>& value);
+
+  static Result<WzPropertyCollection> ParsePropertyList(int64_t offset,
+                                                        WzBinaryReader* reader,
+                                                        WzObject* parent,
+                                                        WzImage* parentImg);
+  static Result<void> WritePropertyList(WzBinaryWriter* writer,
+                                        const WzPropertyCollection& properties);
+  static Result<std::unique_ptr<WzImageProperty>> ParseExtendedProp(
+      int64_t offset,
+      WzBinaryReader* reader,
+      const std::string& name,
+      WzObject* parent,
+      WzImage* parentImg);
+};
+
+}  // namespace wz
+#endif  // WZ_WZIMAGEPROPERTY_H_

package/include/wz/WzObject.h

@@ -0,0 +1,55 @@
+#ifndef WZ_WZOBJECT_H_
+#define WZ_WZOBJECT_H_
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/Util/Defines.h"
+#include "wz/WzEnums.h"
+
+namespace wz {
+
+class WzFile;
+class WzDirectory;
+class WzImage;
+class WzImageProperty;
+class WzPropertyCollection;
+
+class WzObject {
+ public:
+  WzObject() noexcept = default;
+  WZ_DISALLOW_COPY_AND_MOVE(WzObject)
+
+  virtual ~WzObject() = default;
+  virtual std::string Name() const { return name_; }
+  virtual void SetName(const std::string& name) { (void)Rename(name); }
+  virtual Result<void> Rename(const std::string& name);
+  virtual WzObjectType ObjectType() const = 0;
+  virtual WzObject* Parent() const { return parent_; }
+  virtual void SetParent(WzObject* p) { parent_ = p; }
+  virtual WzFile* WzFileParent() const;
+  virtual Result<std::unique_ptr<WzObject>> Remove();
+
+  std::string FullPath() const;
+  WzObject* GetTopMostWzDirectory();
+  WzObject* GetTopMostWzImage();
+
+  // Cast methods
+  virtual int32_t GetInt() const;
+  virtual int16_t GetShort() const;
+  virtual int64_t GetLong() const;
+  virtual float GetFloat() const;
+  virtual double GetDouble() const;
+  virtual std::string GetString() const;
+  virtual Result<std::vector<uint8_t>> GetBytes();
+
+  WzObject* operator[](const std::string& name);
+
+ protected:
+  std::string name_;
+  WzObject* parent_ = nullptr;
+};
+
+}  // namespace wz
+#endif  // WZ_WZOBJECT_H_

package/include/wz/WzPropertyCollection.h

@@ -0,0 +1,115 @@
+#ifndef WZ_WZPROPERTYCOLLECTION_H_
+#define WZ_WZPROPERTYCOLLECTION_H_
+#include <memory>
+#include <utility>
+#include <vector>
+#include "wz/WzObject.h"
+
+namespace wz {
+
+class WzImageProperty;
+class WzPropertyCollection {
+ public:
+  class iterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = WzImageProperty*;
+    using difference_type = std::ptrdiff_t;
+    using pointer = WzImageProperty**;
+    using reference = WzImageProperty*;
+
+    iterator() = default;
+    explicit iterator(
+        std::vector<std::unique_ptr<WzImageProperty>>::iterator it)
+        : it_(it) {}
+
+    WzImageProperty* operator*() const { return it_->get(); }
+    iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    iterator operator++(int) {
+      iterator old = *this;
+      ++(*this);
+      return old;
+    }
+    bool operator==(const iterator& other) const { return it_ == other.it_; }
+    bool operator!=(const iterator& other) const { return !(*this == other); }
+
+   private:
+    friend class WzPropertyCollection;
+    std::vector<std::unique_ptr<WzImageProperty>>::iterator it_;
+  };
+
+  class const_iterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = WzImageProperty*;
+    using difference_type = std::ptrdiff_t;
+    using pointer = WzImageProperty* const*;
+    using reference = WzImageProperty*;
+
+    const_iterator() = default;
+    explicit const_iterator(
+        std::vector<std::unique_ptr<WzImageProperty>>::const_iterator it)
+        : it_(it) {}
+
+    WzImageProperty* operator*() const { return it_->get(); }
+    const_iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    const_iterator operator++(int) {
+      const_iterator old = *this;
+      ++(*this);
+      return old;
+    }
+    bool operator==(const const_iterator& other) const {
+      return it_ == other.it_;
+    }
+    bool operator!=(const const_iterator& other) const {
+      return !(*this == other);
+    }
+
+   private:
+    std::vector<std::unique_ptr<WzImageProperty>>::const_iterator it_;
+  };
+
+  WzPropertyCollection();
+  explicit WzPropertyCollection(WzObject* parent);
+  ~WzPropertyCollection();
+  WZ_DISALLOW_COPY(WzPropertyCollection)
+  WzPropertyCollection(WzPropertyCollection&& other) noexcept;
+  WzPropertyCollection& operator=(WzPropertyCollection&& other) noexcept;
+
+  void Add(WzImageProperty* item);
+  void Add(std::unique_ptr<WzImageProperty> item);
+
+  void Insert(size_t index, WzImageProperty* item);
+  void Insert(size_t index, std::unique_ptr<WzImageProperty> item);
+
+  void erase(iterator it);
+  void erase_at(size_t index);
+  std::unique_ptr<WzImageProperty> Remove(WzImageProperty* item);
+  void clear();
+  std::vector<std::unique_ptr<WzImageProperty>> TakeItems();
+
+  WzImageProperty* operator[](size_t i) { return items_[i].get(); }
+  WzImageProperty* operator[](size_t i) const { return items_[i].get(); }
+
+  size_t size() const { return items_.size(); }
+
+  iterator begin() { return iterator(items_.begin()); }
+  iterator end() { return iterator(items_.end()); }
+  const_iterator begin() const { return const_iterator(items_.begin()); }
+  const_iterator end() const { return const_iterator(items_.end()); }
+
+  WzObject* Parent() const { return parent_; }
+
+ private:
+  std::vector<std::unique_ptr<WzImageProperty>> items_;
+  WzObject* parent_ = nullptr;
+};
+
+}  // namespace wz
+#endif  // WZ_WZPROPERTYCOLLECTION_H_

package/include/wz/wz.h

@@ -0,0 +1,41 @@
+#ifndef WZ_WZ_H_
+#define WZ_WZ_H_
+
+#include "wz/CRC32.h"
+#include "wz/PngUtility.h"
+#include "wz/PortalType.h"
+#include "wz/Result.h"
+#include "wz/WzAESConstant.h"
+#include "wz/WzDirectory.h"
+#include "wz/WzEnums.h"
+#include "wz/WzFile.h"
+#include "wz/WzHeader.h"
+#include "wz/WzImage.h"
+#include "wz/WzImageProperty.h"
+#include "wz/WzObject.h"
+#include "wz/WzPropertyCollection.h"
+
+#include "wz/Properties/WzBinaryProperty.h"
+#include "wz/Properties/WzCanvasProperty.h"
+#include "wz/Properties/WzConvexProperty.h"
+#include "wz/Properties/WzDoubleProperty.h"
+#include "wz/Properties/WzFloatProperty.h"
+#include "wz/Properties/WzIntProperty.h"
+#include "wz/Properties/WzLongProperty.h"
+#include "wz/Properties/WzLuaProperty.h"
+#include "wz/Properties/WzNullProperty.h"
+#include "wz/Properties/WzPngProperty.h"
+#include "wz/Properties/WzRawDataProperty.h"
+#include "wz/Properties/WzShortProperty.h"
+#include "wz/Properties/WzStringProperty.h"
+#include "wz/Properties/WzSubProperty.h"
+#include "wz/Properties/WzUOLProperty.h"
+#include "wz/Properties/WzVectorProperty.h"
+#include "wz/Properties/WzVideoProperty.h"
+
+#include "wz/Util/ListFileParser.h"
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzKeyGenerator.h"
+#include "wz/Util/WzMutableKey.h"
+#include "wz/Util/WzTool.h"
+#endif  // WZ_WZ_H_