source.h

/* Copyright 2018 Carnegie Mellon University
 *
 * 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 "scanner/api/kernel.h"
#include "scanner/api/enumerator.h"
#include "scanner/util/common.h"
#include "scanner/util/profiler.h"
#include "scanner/util/storehouse.h"

#include <vector>

namespace scanner {

struct SourceConfig {
  std::vector<std::string> output_columns;
  std::vector<proto::ColumnType> output_column_types;
  std::vector<u8> args;  
  i32 node_id;
  storehouse::StorageConfig* storage_config;
};

class Source {
 public:
  Source(const SourceConfig& config) {}

  virtual ~Source(){};

  virtual void validate(proto::Result* result) { result->set_success(true); }

  virtual void read(const std::vector<ElementArgs>& args,
                    BatchedElements& output_columns) = 0;

  virtual void set_profiler(Profiler* profiler) { profiler_ = profiler; }

  Profiler* profiler_ = nullptr;
};

namespace internal {

class SourceBuilder;

using SourceConstructor =
    std::function<Source*(const SourceConfig& config)>;

class SourceRegistration {
 public:
  SourceRegistration(const SourceBuilder& builder);
};

class SourceBuilder {
 public:
  friend class SourceRegistration;

  SourceBuilder(const std::string& name, SourceConstructor constructor)
    : name_(name),
      constructor_(constructor) {}

  SourceBuilder& output(const std::string& name,
                    ColumnType type = ColumnType::Bytes) {
    if (output_columns_.size() > 0) {
      LOG(FATAL) << "Sources can only have one output column.";
    }
    output_columns_.push_back(std::make_tuple(name, type));
    return *this;
  }

  SourceBuilder& frame_output(const std::string& name) {
    return output(name, ColumnType::Video);
  }

  SourceBuilder& protobuf_name(const std::string& name) {
    protobuf_name_ = name;
    return *this;
  }

 private:
  std::string name_;
  SourceConstructor constructor_;
  std::vector<std::tuple<std::string, ColumnType>> output_columns_;
  std::string protobuf_name_;
};
}

#define REGISTER_SOURCE(name__, source__)              \
  REGISTER_SOURCE_HELPER(__COUNTER__, name__, source__)

#define REGISTER_SOURCE_HELPER(uid__, name__, source__) \
  REGISTER_SOURCE_UID(uid__, name__, source__)

#define REGISTER_SOURCE_UID(uid__, name__, source__)                         \
  static ::scanner::internal::SourceRegistration source_registration_##uid__ \
      __attribute__((unused)) = ::scanner::internal::SourceBuilder(          \
          #name__, [](const ::scanner::SourceConfig& config) {               \
            return new source__(config);                                     \
          })
}