#pragma once

#ifndef GEODE_PDXAUTOSERIALIZER_BASE_TYPES_H_
#define GEODE_PDXAUTOSERIALIZER_BASE_TYPES_H_

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 <string>
#include <vector>
#include <set>
#include <map>
#include <cassert>
#include <stdexcept>

namespace apache {
namespace geode {
namespace client {
namespace pdx_auto_serializer {
/** Shorthand for vector of strings. */
typedef std::vector<std::string> StringVector;

/** Shorthand for set of strings. */
typedef std::set<std::string> StringSet;

/**
 * Shorthand for the <code>std::map</code> containing property
 * key-value pairs.
 */
typedef std::map<std::string, StringVector> PropertyMap;

/**
 * Shorthand for the <code>std::map</code> containing string
 * key-value pairs.
 */
typedef std::map<std::string, std::string> StringMap;

/**
 * Shorthand for the <code>std::map</code> containing string
 * keys mapped to usage string and boolean indicator of option
 * requiring a value.
 */
typedef std::map<std::string, std::pair<bool, std::string> > OptionMap;

/** Shorthand for iterator of vector of strings. */
typedef std::vector<std::string>::const_iterator StringVectorIterator;

/** Shorthand for iterator of set of strings. */
typedef std::set<std::string>::const_iterator StringSetIterator;

/**
 * Encapsulates different kinds of references (headers/dlls etc).
 */
class Reference {
 public:
  enum Kind {
    /** Indicates a C++ header file. */
    HEADER,

    /** Indicates a library (so/dll). */
    LIB,

    /** Indicates a jar file (Java). */
    JAR
  };
};

/**
 * Structure to hold information of a reference (e.g. header/dll).
 */
struct ReferenceInfo {
  /** Path of the reference. */
  std::string m_path;

  /** the <code>Reference::Kind</code> of the reference. */
  Reference::Kind m_kind;
};

/**
 * Encapsulates different kinds of types like <code>VALUE</code>,
 * <code>ARRAY</code> etc.
 *
 * Also includes the information whether the type is a built-in one or
 * a user-defined type, and whether the type is a .NET managed type.
 */
class TypeKind {
 public:
  /** An invalid type. */
  static const int INVALID = 0x0;

  /** A value type. */
  static const int VALUE = 0x01;

  /** A pointer type. */
  static const int POINTER = 0x02;

  /** A reference type or pass by reference. */
  static const int REFERENCE = 0x04;

  /** An array type with fixed/dynamic size. */
  static const int ARRAY = 0x08;

  /**
   * The array is of fixed size -- both this and <code>ARRAY</code>
   * bits should be set for fixed size arrays.
   */
  static const int FIXEDARRAY = 0x10;

  /** A C++ template or .NET/Java generic type. */
  static const int TEMPLATE = 0x20;

  /** The type is actually a template parameter symbol. */
  static const int TEMPLATEPARAM = 0x40;

  /**
   * Indicates that the type is a .NET managed type -- required for
   * generators like C++/CLI that understand both normal objects as
   * well as .NET types.
   */
  static const int MANAGED = 0x100;

  /**
   * Indicates that the type is a builtin one. This will be normally
   * OR'd with one of the actual kinds above. If this bit is not set
   * then the type is assumed to be a user-defined type.
   */
  static const int BUILTIN = 0x200;
};

/**
 * Mask to extract the Type part only from the constants in
 * <code>TypeKind</code> class.
 */
const int TYPEKIND_TYPEMASK = 0xFF;

/**
 * Constants for the possible kinds of type modifiers.
 */
class TypeModifier {
 public:
  /** No modifier. */
  static const int NONE = 0x01;

  /** The type is defined to be a constant. */
  static const int CONSTANT = 0x02;

  /** The type is defined to be volatile. */
  static const int VOLATILE = 0x04;

  /** The member is private to the class. */
  static const int PRIVATE = 0x08;

  /** The member is declared to be protected. */
  static const int PROTECTED = 0x10;

  /** The member is declared to be public. */
  static const int PUBLIC = 0x20;

  /** The member is declared to be internal (.NET). */
  static const int INTERNAL = 0x40;

  /** The member is a property (.NET). */
  static const int PROPERTY = 0x80;

  /** The member is defined to be transient (Java). */
  static const int TRANSIENT = 0x100;
};

/**
 * Structure to hold information for a type.
 */
struct TypeInfo {
  /** The {@link apache::geode::client::pdx_auto_serializer::TypeKind} of the
   * type. */
  int m_kind;

  /** The {@link apache::geode::client::pdx_auto_serializer::TypeModifier} for
   * the type. */
  int m_modifier;

  /**
   * Contains either the name of the variable, or for the case of
   * <code>FIXEDARRAY</code> or <code>ARRAY</code>, the size of the array,
   * name of variable containing the size respectively.
   */
  std::string m_nameOrSize;

  std::string m_nameOfArrayElemSize;

  /** The namespace for the type expressed as a vector. */
  StringVector m_namespaces;

  /**
   * Information of any child sub-types for the case of
   * <code>POINTER</code>, <code>REFERENCE</code> or
   * <code>TEMPLATE</code> types.
   */
  TypeInfo* m_children;

  /**
   *  The number of child sub-types. Can be greater than one for the case
   *  of <code>TEMPLATE</code> types.
   */
  int m_numChildren;
};

/**
 * Structure to hold information for a variable.
 */
struct VariableInfo {
  /** The type of the variable. */
  TypeInfo m_type;

  bool m_markIdentityField;
  bool m_markPdxUnreadField;
  /** The name of the variable. */
  std::string m_name;
};

/** Shorthand for a vector of <code>ReferenceInfo</code>. */
typedef std::vector<ReferenceInfo> ReferenceVector;

/**
 * Shorthand for <code>const_iterator</code> of a vector of
 * <code>ReferenceInfo</code>.
 */
typedef std::vector<ReferenceInfo>::const_iterator ReferenceVectorIterator;

/** Shorthand for a vector of <code>VariableInfo</code>. */
typedef std::vector<VariableInfo> VariableVector;

/**
 * Shorthand for <code>const_iterator</code> of a vector of
 * <code>VariableInfo</code>.
 */
typedef std::vector<VariableInfo>::const_iterator VariableVectorIterator;
}  // namespace pdx_auto_serializer
}  // namespace client
}  // namespace geode
}  // namespace apache

#endif  // GEODE_PDXAUTOSERIALIZER_BASE_TYPES_H_