behavior.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
 
#ifndef CORE_BEHAVIOR_BEHAVIOR_H_
#define CORE_BEHAVIOR_BEHAVIOR_H_
 
#include <limits>
#include "core/agent/agent.h"
#include "core/agent/new_agent_event.h"
#include "core/util/type.h"
 
namespace bdm {
 
class Behavior {
 public:
  Behavior() : copy_mask_(0), remove_mask_(0) {}
 
  virtual ~Behavior() = default;
 
  virtual Behavior* New() const = 0;
 
  virtual Behavior* NewCopy() const = 0;
 
  virtual void Initialize(const NewAgentEvent& event) {
    copy_mask_ = event.existing_behavior->copy_mask_;
    remove_mask_ = event.existing_behavior->remove_mask_;
  }
 
  virtual void Update(const NewAgentEvent& event) {}
 
  virtual void Run(Agent* agent) = 0;
 
  void AlwaysCopyToNew() {
    copy_mask_ = std::numeric_limits<NewAgentEventUid>::max();
  }
  void NeverCopyToNew() { copy_mask_ = 0; }
  void CopyToNewIf(const std::initializer_list<NewAgentEventUid>& uids) {
    for (auto& uid : uids) {
      copy_mask_ |= uid;
    }
  }
 
  void AlwaysRemoveFromExisting() {
    remove_mask_ = std::numeric_limits<NewAgentEventUid>::max();
  }
  void NeverRemoveFromExisting() { remove_mask_ = 0; }
  void RemoveFromExistingIf(
      const std::initializer_list<NewAgentEventUid>& uids) {
    for (auto& uid : uids) {
      remove_mask_ |= uid;
    }
  }
 
  bool WillBeCopied(NewAgentEventUid event) const {
    return (event & copy_mask_) != 0;
  }
 
  bool WillBeRemoved(NewAgentEventUid event) const {
    return (event & remove_mask_) != 0;
  }
 
  void* operator new(size_t size) {  // NOLINT
    auto* mem_mgr = Simulation::GetActive()->GetMemoryManager();
    if (mem_mgr) {
      return mem_mgr->New(size);
    } else {
      return malloc(size);
    }
  }
 
  void operator delete(void* p) {  // NOLINT
    auto* mem_mgr = Simulation::GetActive()->GetMemoryManager();
    if (mem_mgr) {
      mem_mgr->Delete(p);
    } else {
      free(p);
    }
  }
 
 private:
  NewAgentEventUid copy_mask_ = 0;
  NewAgentEventUid remove_mask_ = 0;
  BDM_CLASS_DEF(Behavior, 2);
};
 
#define BDM_BEHAVIOR_HEADER(class_name, base_class, class_version_id)        \
 public:                                                                     \
  using Base = base_class;                                                   \
 \
  Behavior* New() const override { return new class_name(); }                \
    \
  Behavior* NewCopy() const override { return new class_name(*this); }       \
                                                                             \
 private:                                                                    \
  BDM_CLASS_DEF_OVERRIDE(class_name, class_version_id);                      \
                                                                             \
 public:
 
}  // namespace bdm
 
#endif  // CORE_BEHAVIOR_BEHAVIOR_H_