literal.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 <utility>
#include <optional>
#include <string>
#include <memory>
#include <vector>
#include <unordered_map>
 
#include "cerata/object.h"
#include "cerata/type.h"
#include "cerata/node.h"
 
namespace cerata {
 
class Literal : public MultiOutputNode {
 public:
  enum class StorageType { INT, UINT, STRING, BOOL };
 protected:
  Literal(std::string name,
          const std::shared_ptr<Type> &type,
          StorageType st,
          std::string str_val,
          int64_t int_val,
          bool bool_val)
      : MultiOutputNode(std::move(name), Node::NodeID::LITERAL, type),
        storage_type_(st),
        Bool_val_(bool_val),
        Int_val_(int_val),
        String_val_(std::move(str_val)) {}
 
  StorageType storage_type_;
 
  // Macros to generate Literal functions for different storage types.
#define LITERAL_DECL_FACTORY(NAME, TYPENAME)                                                                        \
 public:                                                                                                            \
  explicit Literal(std::string name, const std::shared_ptr<Type> &type, TYPENAME value);                            \
  static std::shared_ptr<Literal> Make##NAME(TYPENAME value);                                                       \
  static std::shared_ptr<Literal> Make##NAME(const std::shared_ptr<Type> &type, TYPENAME value);                    \
  static std::shared_ptr<Literal> Make##NAME(std::string name, const std::shared_ptr<Type> &type, TYPENAME value);  \
  TYPENAME NAME##Value() const { return NAME##_val_; }                                                              \
                                                                                                                    \
 protected:                                                                                                         \
  TYPENAME NAME##_val_ {}
 
 LITERAL_DECL_FACTORY(Bool, bool); //NOLINT
 LITERAL_DECL_FACTORY(Int, int64_t); //NOLINT
 LITERAL_DECL_FACTORY(String, std::string); //NOLINT
 
 public:
  void SetParent(Graph *graph) override;
  static std::shared_ptr<Literal> Make(bool value) { return MakeBool(value); }
  static std::shared_ptr<Literal> Make(int64_t value) { return MakeInt(value); }
  static std::shared_ptr<Literal> Make(std::string value) { return MakeString(std::move(value)); }
 
  std::shared_ptr<Object> Copy() const override;
 
  inline std::vector<Edge *> sources() const override { return {}; }
  inline std::vector<Edge *> sinks() const override { return ToRawPointers(outputs_); }
 
  std::string ToString() const override;
 
  StorageType storage_type() const { return storage_type_; }
};
 
template<typename T>
T RawValueOf(const Literal &node) { throw std::runtime_error("Can not obtain raw value for type."); }
 
template<>
inline bool RawValueOf(const Literal &node) { return node.BoolValue(); }
 
template<>
inline int64_t RawValueOf(const Literal &node) { return node.IntValue(); }
 
template<>
inline std::string RawValueOf(const Literal &node) { return node.StringValue(); }
 
template<typename T>
Literal::StorageType StorageTypeOf() { throw std::runtime_error("Type has no known StorageType."); }
 
template<>
inline Literal::StorageType StorageTypeOf<bool>() { return Literal::StorageType::BOOL; }
 
template<>
inline Literal::StorageType StorageTypeOf<int64_t>() { return Literal::StorageType::INT; }
 
template<>
inline Literal::StorageType StorageTypeOf<uint64_t>() { return Literal::StorageType::UINT; }
 
template<>
inline Literal::StorageType StorageTypeOf<std::string>() { return Literal::StorageType::STRING; }
 
}  // namespace cerata