/*

* Copyright (c) 2016 PLUMgrid, Inc.

*

* 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.

*/

#include <unistd.h>

#include <iostream>

#include "common.h"

#include "compat/linux/bpf.h"

#include "table_storage.h"

#include "table_storage_impl.h"

namespace ebpf {

using std::string;

using std::unique_ptr;

/// A process-wide singleton of shared tables

class SharedTableStorage : public TableStorageImpl {

public:

class iterator : public TableStorageIteratorImpl {

std::map<string, TableDesc>::iterator it_;

public:

explicit iterator(const std::map<string, TableDesc>::iterator &it) : it_(it) {}

virtual ~iterator() {}

virtual unique_ptr<self_type> clone() const override { return make_unique<iterator>(it_); }

virtual self_type &operator++() override {

++it_;

return *this;

}

virtual value_type &operator*() const override { return *it_; }

virtual pointer operator->() const override { return &*it_; }

};

virtual ~SharedTableStorage() {}

virtual bool Find(const string &name, TableStorage::iterator &result) const override;

virtual bool Insert(const string &name, TableDesc &&desc) override;

virtual bool Delete(const string &name) override;

virtual unique_ptr<TableStorageIteratorImpl> begin() override;

virtual unique_ptr<TableStorageIteratorImpl> end() override;

virtual unique_ptr<TableStorageIteratorImpl> lower_bound(const string &k) override;

virtual unique_ptr<TableStorageIteratorImpl> upper_bound(const string &k) override;

virtual unique_ptr<TableStorageIteratorImpl> erase(const TableStorageIteratorImpl &it) override;

private:

static std::map<string, TableDesc> tables_;

};

bool SharedTableStorage::Find(const string &name, TableStorage::iterator &result) const {

auto it = tables_.find(name);

if (it == tables_.end())

return false;

result = TableStorage::iterator(make_unique<iterator>(it));

return true;

}

bool SharedTableStorage::Insert(const string &name, TableDesc &&desc) {

auto it = tables_.find(name);

if (it != tables_.end())

return false;

tables_[name] = std::move(desc);

return true;

}

bool SharedTableStorage::Delete(const string &name) {

auto it = tables_.find(name);

if (it == tables_.end())

return false;

tables_.erase(it);

return true;

}

unique_ptr<TableStorageIteratorImpl> SharedTableStorage::begin() {

return make_unique<iterator>(tables_.begin());

}

unique_ptr<TableStorageIteratorImpl> SharedTableStorage::end() {

return make_unique<iterator>(tables_.end());

}

unique_ptr<TableStorageIteratorImpl> SharedTableStorage::lower_bound(const string &k) {

return make_unique<iterator>(tables_.lower_bound(k));

}

unique_ptr<TableStorageIteratorImpl> SharedTableStorage::upper_bound(const string &k) {

return make_unique<iterator>(tables_.upper_bound(k));

}

unique_ptr<TableStorageIteratorImpl> SharedTableStorage::erase(const TableStorageIteratorImpl &it) {

auto i = tables_.find((*it).first);

if (i == tables_.end())

return unique_ptr<iterator>();

return make_unique<iterator>(tables_.erase(i));

}

// All maps for this process are kept in global static storage.

std::map<string, TableDesc> SharedTableStorage::tables_;

unique_ptr<TableStorage> createSharedTableStorage() {

auto t = make_unique<TableStorage>();

t->Init(make_unique<SharedTableStorage>());

t->AddMapTypesVisitor(createJsonMapTypesVisitor());

return t;

}

}