type.h

// Copyright 2018-2019 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <optional>
#include <utility>
#include <memory>
#include <vector>
#include <unordered_map>
#include <string>
#include <tuple>
 
#include "cerata/utils.h"
#include "cerata/flattype.h"
#include "cerata/domain.h"
 
namespace cerata {
 
// Forward decl.
class Object;
class Node;
class Literal;
class Graph;
std::shared_ptr<Literal> intl(int64_t);
typedef std::unordered_map<const Node *, Node *> NodeMap;
 
class Type : public Named, public std::enable_shared_from_this<Type> {
 public:
  //
  //                Physical | Generic | Nested
  //                ---------|---------|-----------
  enum ID {
    BIT,      
    VECTOR,   
 
    INTEGER,  
    STRING,   
    BOOLEAN,  
 
    RECORD    
  };
 
  explicit Type(std::string name, ID id);
 
  inline ID id() const { return id_; }
 
  virtual bool IsEqual(const Type &other) const;
 
  bool Is(ID type_id) const;
  virtual bool IsPhysical() const = 0;
  virtual bool IsNested() const = 0;
  virtual bool IsGeneric() const = 0;
  virtual std::optional<Node *> width() const { return std::nullopt; }
  std::string ToString(bool show_meta = false, bool show_mappers = false) const;
 
  std::vector<std::shared_ptr<TypeMapper>> mappers() const;
  void AddMapper(const std::shared_ptr<TypeMapper> &mapper, bool remove_existing = true);
  std::optional<std::shared_ptr<TypeMapper>> GetMapper(Type *other, bool generate_implicit = true);
  int RemoveMappersTo(Type *other);
  std::optional<std::shared_ptr<TypeMapper>> GetMapper(const std::shared_ptr<Type> &other);
  virtual bool CanGenerateMapper(const Type &other) const { return false; }
  virtual std::shared_ptr<TypeMapper> GenerateMapper(Type *other) { return nullptr; }
 
  virtual std::vector<Node *> GetGenerics() const { return {}; }
  virtual std::vector<Type *> GetNested() const { return {}; }
 
  std::unordered_map<std::string, std::string> meta;
 
  virtual std::shared_ptr<Type> Copy(const NodeMap &rebinding) const = 0;
 
  virtual std::shared_ptr<Type> Copy() const { return Copy({}); }
 
  std::shared_ptr<Type> operator()(std::vector<Node *> nodes);
 
  std::shared_ptr<Type> operator()(const std::vector<std::shared_ptr<Node>> &nodes);
 
 protected:
  ID id_;
  std::vector<std::shared_ptr<TypeMapper>> mappers_;
};
 
std::shared_ptr<Type> bit(const std::string &name = "bit");
struct Bit : public Type {
  bool IsPhysical() const override { return true; }
  bool IsGeneric() const override { return false; }
  bool IsNested() const override { return false; }
  explicit Bit(std::string name) : Type(std::move(name), Type::BIT) {}
  std::optional<Node *> width() const override;
 
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override;
};
 
std::shared_ptr<Type> boolean();
struct Boolean : public Type {
  explicit Boolean(std::string name) : Type(std::move(name), Type::BOOLEAN) {}
  bool IsPhysical() const override { return false; }
  bool IsGeneric() const override { return false; }
  bool IsNested() const override { return false; }
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override { return boolean(); }
};
 
std::shared_ptr<Type> integer();
struct Integer : public Type {
  explicit Integer(std::string name) : Type(std::move(name), Type::INTEGER) {}
  bool IsPhysical() const override { return false; }
  bool IsGeneric() const override { return false; }
  bool IsNested() const override { return false; }
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override { return integer(); }
};
 
std::shared_ptr<Type> string();
struct String : public Type {
  explicit String(std::string name) : Type(std::move(name), Type::STRING) {}
  bool IsPhysical() const override { return false; }
  bool IsGeneric() const override { return false; }
  bool IsNested() const override { return false; }
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override { return string(); }
};
 
class Vector : public Type {
 public:
  bool IsPhysical() const override { return true; }
  bool IsGeneric() const override { return true; }
  bool IsNested() const override { return false; }
 
  Vector(std::string name, const std::shared_ptr<Node> &width);
  std::optional<Node *> width() const override;
  Type &SetWidth(std::shared_ptr<Node> width);
  bool IsEqual(const Type &other) const override;
  std::vector<Node *> GetGenerics() const override;
 
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override;
 
 private:
  std::shared_ptr<Node> width_;
};
 
std::shared_ptr<Type> vector(const std::string &name, const std::shared_ptr<Node> &width);
std::shared_ptr<Type> vector(const std::shared_ptr<Node> &width);
std::shared_ptr<Type> vector(unsigned int width);
std::shared_ptr<Type> vector(std::string name, unsigned int width);
 
class Field : public Named, public std::enable_shared_from_this<Field> {
 public:
  Field(std::string name, std::shared_ptr<Type> type, bool reverse = false, bool sep = true);
  Field &SetType(std::shared_ptr<Type> type);
  std::shared_ptr<Type> type() const { return type_; }
  bool reversed() const { return reverse_; }
  std::shared_ptr<Field> Reverse();
  bool sep() const { return sep_; }
  void NoSep() { sep_ = false; }
  void UseSep() { sep_ = true; }
  std::unordered_map<std::string, std::string> meta;
  std::shared_ptr<Field> Copy(const NodeMap &rebinding) const;
 
 private:
  std::shared_ptr<Type> type_;
  bool reverse_;
  bool sep_;
};
 
std::shared_ptr<Field> field(const std::string &name,
                             const std::shared_ptr<Type> &type,
                             bool reverse = false,
                             bool sep = true);
 
std::shared_ptr<Field> field(const std::shared_ptr<Type> &type, bool reverse = false, bool sep = true);
 
std::shared_ptr<Field> NoSep(std::shared_ptr<Field> field);
 
class Record : public Type {
 public:
  bool IsPhysical() const override;
  bool IsGeneric() const override;
  bool IsNested() const override { return true; }
 
  explicit Record(std::string name, std::vector<std::shared_ptr<Field>> fields = {});
  Record &AddField(const std::shared_ptr<Field> &field, std::optional<size_t> index = std::nullopt);
  bool Has(const std::string &name) const;
  Field *at(const std::string &name) const;
  Field *at(size_t i) const;
  Field *operator[](size_t i) const;
  Field *operator[](const std::string& name) const;
  std::vector<std::shared_ptr<Field>> fields() const { return fields_; }
  inline size_t num_fields() const { return fields_.size(); }
  bool IsEqual(const Type &other) const override;
  std::vector<Node *> GetGenerics() const override;
  std::vector<Type *> GetNested() const override;
 
  std::shared_ptr<Type> Copy(const NodeMap &rebinding) const override;
 
  std::string ToStringFieldNames() const;
 
 protected:
  std::vector<std::shared_ptr<Field>> fields_;
};
 
std::shared_ptr<Record> record(const std::string &name);
 
std::shared_ptr<Record> record(const std::string &name,
                               const std::vector<std::shared_ptr<Field>> &fields);
 
std::shared_ptr<Record> record(const std::vector<std::shared_ptr<Field>> &fields);
 
 
std::shared_ptr<Record> record(const std::initializer_list<std::shared_ptr<Field>> &fields);
 
}  // namespace cerata