example.h

Go to the documentation of this file.

// Copyright 2014, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//   * Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above
//     copyright notice, this list of conditions and the following disclaimer
//     in the documentation and/or other materials provided with the
//     distribution.
//   * Neither the name of Google Inc. nor the names of its
//     contributors may be used to endorse or promote products derived from
//     this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// -----------------------------------------------------------------------------
//
//

#ifndef INFACT_EXAMPLE_H_
#define INFACT_EXAMPLE_H_

#include <string>

#include "factory.h"

namespace infact {

class Date : public FactoryConstructible {
 public:
  Date() {}
  virtual ~Date() {}

  virtual int year() const = 0;
  virtual int month() const = 0;
  virtual int day() const = 0;
};

#define REGISTER_DATE(TYPE) \
  REGISTER_NAMED(TYPE,TYPE,Date)

class DateImpl : public Date {
 public:
  DateImpl() : Date() {}
  virtual ~DateImpl() {}

  virtual void RegisterInitializers(Initializers &initializers) {
    INFACT_ADD_REQUIRED_PARAM_(year);
    INFACT_ADD_REQUIRED_PARAM_(month);
    INFACT_ADD_REQUIRED_PARAM_(day);
  }

  virtual int year() const { return year_; }
  virtual int month() const { return month_; }
  virtual int day() const { return day_; }

 private:
  int year_;
  int month_;
  int day_;
};

class Person : public FactoryConstructible {
 public:
  Person() {}
  virtual ~Person() {}

  virtual const string &name() const = 0;
  virtual const int cm_height() const = 0;
  virtual shared_ptr<const Date> birthday() const = 0;
};

#define REGISTER_PERSON(TYPE) \
  REGISTER_NAMED(TYPE,TYPE,Person)

class PersonImpl : public Person {
 public:
  PersonImpl() : Person() {}
  virtual ~PersonImpl() {}

  virtual void RegisterInitializers(Initializers &initializers) {
    INFACT_ADD_REQUIRED_PARAM_(name);
    INFACT_ADD_PARAM_(cm_height);
    INFACT_ADD_PARAM_(birthday);
  }

  virtual const string &name() const { return name_; }
  virtual const int cm_height() const { return cm_height_; }
  virtual shared_ptr<const Date> birthday() const { return birthday_; }

 private:
  string name_;
  int cm_height_;
  shared_ptr<Date> birthday_;
};

class Animal : public FactoryConstructible {
 public:
  Animal() {}
  virtual ~Animal() {}

  virtual const string &name() const = 0;

  virtual int age() const = 0;
};

#define REGISTER_ANIMAL(TYPE) \
  REGISTER_NAMED(TYPE,TYPE,Animal)

class Cow : public Animal {
public:
  Cow() : Animal() {
    age_ = 2; // default age, since age is optional
  }

  // Destroys this instance.
  virtual ~Cow() {}

  virtual void RegisterInitializers(Initializers &initializers) {
    INFACT_ADD_REQUIRED_PARAM_(name);
    INFACT_ADD_PARAM_(age);
  }

  virtual const string &name() const { return name_; }
  virtual int age() const { return age_; }
private:
  string name_;
  int age_;
};

class Sheep : public Animal {
 public:
  Sheep() : Animal() {}
  virtual ~Sheep() {}

  virtual void RegisterInitializers(Initializers &initializers) {
    INFACT_ADD_REQUIRED_PARAM_(name);
    INFACT_ADD_PARAM_(counts);
    // We can pass in a nullptr, if we don't want to directly
    // initialize a data member of this class, but instead want to
    // simply grab something from the Environment after this method
    // has been invoked; see the PostInit method declared below
    // (defined in example.cc).
    //
    // As of v1.0.6, the new INFACT_ADD_TEMPORARY macro makes it very
    // easy to add such temporary variables in a very readable way.
    INFACT_ADD_TEMPORARY(int, age);
  }

  virtual void PostInit(const Environment *env, const string &init_str);

  virtual const string &name() const { return name_; }
  virtual int age() const {
    return -1;  // Always returns -1, because sheep are timeless.
  }
  const vector<int> &counts() { return counts_; }
 private:
  string name_;
  int age_;
  // The various times people have counted this sheep when falling asleep.
  vector<int> counts_;
};

class PetOwner : public FactoryConstructible {
 public:
  PetOwner() {}

  virtual ~PetOwner() {}

  virtual int GetNumberOfPets() = 0;

  virtual shared_ptr<Animal> GetPet(int i) = 0;
};

#define REGISTER_PET_OWNER(TYPE) \
  REGISTER_NAMED(TYPE,TYPE,PetOwner)

class HumanPetOwner : public PetOwner {
 public:
  HumanPetOwner() : PetOwner() {}

  virtual ~HumanPetOwner() {}

  virtual void RegisterInitializers(Initializers &initializers) {
    initializers.Add("pets", &pets_, true);
  }

  virtual int GetNumberOfPets() {
    return pets_.size();
  }

  virtual shared_ptr<Animal> GetPet(int i) {
    return pets_.at(i);
  }

 private:
  vector<shared_ptr<Animal> > pets_;
};

}  // namespace infact

#endif