bibentry.hpp

// bibhtml: Generates HTML page (with images) from BibTex files
// See: https://www.telecom-paris.fr/~elc/software/
//
// Copyright 2020 Eric Lecolinet (eric.lecolinet@gmail.com)
//
// 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.

#ifndef __BibEntry__
#define __BibEntry__
#include <list>
#include <map>
#include "bibdefs.hpp"

class Bib;


class BibAuthor {
public:
  BibAuthor(const std::string& lastname, const std::string& firstname);
  
  std::string lastname_, firstname_, sortname_;
  class BibGroup* authgroup_;
  class AuthStats* stats_;
};


class BibAuthors : public std::list<BibAuthor*> {};



class BibEntry {
public:
  struct Field {std::string raw, parsed;};
  using Fields = std::map<BibFields::ID, Field>;
  
  BibEntry(const std::string& key, const std::string& typeName,
           BibTypes::ID typeID, bool isAuxiliary);
  
  virtual ~BibEntry() = default;
  
  BibTypes::ID typeID() const {return type_;}
  
  const std::string& bibkey() const;

  bool isAuxiliary() const {return isAuxiliary_;}

  const std::string& field(BibFields::ID) const;
  
  void setField(BibFields::ID, const std::string& raw, const std::string& parsed);
  
  void setParsedField(BibFields::ID, const std::string& parsed);

  const Fields& fields() const {return fields_;}

  const BibAuthors& authors() const {return authors_;}

  void setMediaAndRank(class Bib&);
  
private:
  friend class Bib;
  friend class BibEntryNode;
  friend class BibReader;
  BibTypes::ID type_;
  bool isAuxiliary_{false};
  Fields fields_;
  BibAuthors authors_;
};


class BibGroup : public BibEntry {
public:
  BibGroup(const std::string& name, const std::string& typeName,
           BibTypes::ID typeID, bool isAuxiliary);
  
  const std::string& name() const {return name_;}

  std::string name_;
  class AuthStats* stats_;
};


class BibEntryNode {
public:
  BibEntryNode(BibEntry& entry)
  : entry_(entry), index_(0), author_(nullptr) {}

  BibEntryNode(BibEntry& entry, int index, const BibAuthor* author = nullptr)
  : entry_(entry), index_(index), author_(author) {}
  
  BibTypes::ID getTypeID() const {return entry_.type_;}
  
  const std::string& bibkey() const {return entry_.bibkey();}
  
  bool isAuxiliary() const {return entry_.isAuxiliary_;}
  
  const std::string& field(BibFields::ID id) const;
  
  void setField(BibFields::ID id, const std::string& raw, const std::string& parsed) {
    entry_.setField(id, raw, parsed);
  }
  
  void setParsedField(BibFields::ID id, const std::string& parsed) {
    entry_.setParsedField(id, parsed);
  }
  
  const BibAuthors& authors() const {return entry_.authors_;}

  void setMediaAndRank(class Bib& btw) {entry_.setMediaAndRank(btw);}
  
  BibEntry& entry_;
  int index_;
  const BibAuthor* author_;
};


class BibEntries : public std::list<BibEntryNode> {
public:
  BibEntries* find(const std::string& query, bool ignoreCase, bool abridgedFields) const;
  

  BibEntries* sort(const std::string& pattern, bool abridged) const;
  
  void setMediaAndRank(Bib&);
};

#endif