Google OR-Tools: ortools/sat/model.h Source File

47 template <typename Type>

48 static inline size_t FastTypeId() {

49 static_assert(sizeof(char*) <= sizeof(size_t),

50 "ptr size too large for size_t");

54 static char dummy_var;

55 return reinterpret_cast<size_t>(&dummy_var);

56 }

58 public:

64 for (int i = cleanup_list_.size() - 1; i >= 0; --i) {

65 cleanup_list_[i].reset();

66 }

67 }

73 explicit Model(std::string name) : name_(name) {}

103 template <typename T>

105 return f(this);

106 }

107

109 template <typename T>

110 T Get(std::function<T(const Model&)> f) const {

111 return f(*this);

112 }

113

128 template <typename T>

130 const size_t type_id = FastTypeId<T>();

131 auto find = singletons_.find(type_id);

132 if (find != singletons_.end()) {

133 return static_cast<T*>(find->second);

134 }

135

136

137

138 T* new_t = MyNew<T>(0);

139 singletons_[type_id] = new_t;

141 return new_t;

142 }

143

149 template <typename T>

150 const T* Get() const {

151 const auto& it = singletons_.find(FastTypeId<T>());

152 return it != singletons_.end() ? static_cast<const T*>(it->second)

153 : nullptr;

154 }

155

159 template <typename T>

161 const auto& it = singletons_.find(FastTypeId<T>());

162 return it != singletons_.end() ? static_cast<T*>(it->second) : nullptr;

163 }

164

170 template <typename T>

172 cleanup_list_.emplace_back(new Delete<T>(t));

173 return t;

174 }

175

181 template <typename T>

183 T* new_t = MyNew<T>(0);

185 return new_t;

186 }

187

193 template <typename T>

195 const size_t type_id = FastTypeId<T>();

196 CHECK(!singletons_.contains(type_id));

197 singletons_[type_id] = non_owned_class;

198 }

199

200 const std::string& Name() const { return name_; }

201

202 private:

203

204

205

206

207

208 template <typename T>

209 decltype(T(static_cast<Model*>(nullptr)))* MyNew(int) {

210 return new T(this);

211 }

212 template <typename T>

213 T* MyNew(...) {

214 return new T();

215 }

216

217 const std::string name_;

218

219

220 absl::flat_hash_map< size_t, void*> singletons_;

221

222 struct DeleteInterface {

223 virtual ~DeleteInterface() = default;

224 };

225 template <typename T>

226 class Delete : public DeleteInterface {

227 public:

228 explicit Delete(T* t) : to_delete_(t) {}

229 ~Delete() override = default;

230

231 private:

232 std::unique_ptr<T> to_delete_;

233 };

234

235

236

237

238

239

240 std::vector<std::unique_ptr<DeleteInterface>> cleanup_list_;

241};