latest/doxygen/PE_2Binary_8hpp_source.html

/* Copyright 2017 - 2024 R. Thomas

 * Copyright 2017 - 2024 Quarkslab

 *

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

#define LIEF_PE_BINARY_H


#include "LIEF/PE/Header.hpp"

#include "LIEF/PE/OptionalHeader.hpp"

#include "LIEF/PE/DosHeader.hpp"

#include "LIEF/PE/Import.hpp"

#include "LIEF/PE/DelayImport.hpp"

#include "LIEF/PE/Symbol.hpp"

#include "LIEF/PE/DataDirectory.hpp"

#include "LIEF/PE/ResourcesManager.hpp"

#include "LIEF/PE/signature/Signature.hpp"


#include "LIEF/Abstract/Binary.hpp"


#include "LIEF/visibility.h"


namespace LIEF {

namespace PE {

class Builder;

class CodeViewPDB;

class Debug;

class Export;

class LoadConfiguration;

class Parser;

class Relocation;

class ResourceData;

class ResourceDirectory;

class ResourceNode;

class RichHeader;

class TLS;

class LIEF_API Binary : public LIEF::Binary {

  friend class Parser;

  friend class Builder;


  public:  using sections_t = std::vector<std::unique_ptr<Section>>;

  using it_sections = ref_iterator<sections_t&, Section*>;

  using it_const_sections = const_ref_iterator<const sections_t&, const Section*>;

  using data_directories_t = std::vector<std::unique_ptr<DataDirectory>>;

  using it_data_directories = ref_iterator<data_directories_t&, DataDirectory*>;

  using it_const_data_directories = const_ref_iterator<const data_directories_t&, const DataDirectory*>;

  using relocations_t = std::vector<std::unique_ptr<Relocation>>;

  using it_relocations = ref_iterator<relocations_t&, Relocation*>;

  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;

  using imports_t = std::vector<Import>;

  using it_imports = ref_iterator<imports_t&>;

  using it_const_imports = const_ref_iterator<const imports_t&>;

  using delay_imports_t = std::vector<DelayImport>;

  using it_delay_imports = ref_iterator<delay_imports_t&>;

  using it_const_delay_imports = const_ref_iterator<const delay_imports_t&>;

  using debug_entries_t = std::vector<std::unique_ptr<Debug>>;

  using it_debug_entries = ref_iterator<debug_entries_t&, Debug*>;

  using it_const_debug_entries = const_ref_iterator<const debug_entries_t&, const Debug*>;

  using symbols_t = std::vector<Symbol>;

  using it_symbols = ref_iterator<symbols_t&>;

  using it_const_symbols = const_ref_iterator<const symbols_t&>;

  using strings_table_t = std::vector<std::string>;

  using it_strings_table = ref_iterator<strings_table_t&>;

  using it_const_strings_table = const_ref_iterator<const strings_table_t&>;

  using signatures_t = std::vector<Signature>;

  using it_signatures = ref_iterator<signatures_t&>;

  using it_const_signatures = const_ref_iterator<const signatures_t&>;


  Binary(PE_TYPE type);


  ~Binary() override;

  PE_TYPE type() const {

    return type_;

  }