Enumerations.h

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
 * of this source code or associated reference material to any other location for further reproduction
 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */

#pragma once

#include <OnixS/Senaf/MarketData/Export.h>

#include <string>

namespace OnixS { namespace Senaf { namespace MarketData {

/// Flow Type.
struct ONIXS_BME_SENAF_EXPORT FlowType
{
    /// \copydoc FlowType
    enum Enum
    {
        /// Undefined.
        Undefined = 0x0,

        /// Back-Office.
        BackOffice = 0x01,

        /// Non-Operative Short Market.
        NonOperativeShortMarket = 0x05,

        /// Short Market.
        ShortMarket = 0x06
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// System Error Code.
struct ONIXS_BME_SENAF_EXPORT SystemErrorCode
{
    /// \copydoc SystemErrorCode
    enum Enum
    {
        /// Unknown.
        Unknown = 0,

        /// Terminal Error.
        TerminalError = 1,

        /// Server Error.
        ServerError = 2,

        /// Senaf Error.
        SenafError = 3
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Side.
struct ONIXS_BME_SENAF_EXPORT Side
{
    /// \copydoc Side
    enum Enum
    {
        /// Undefined.
        Undefined = 0,

        /// Bid.
        Bid = 1,

        /// Ask.
        Ask = 2
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Buy / Sell.
struct ONIXS_BME_SENAF_EXPORT BuySell
{
    /// \copydoc BuySell
    enum Enum
    {
        /// Undefined.
        Undefined = 0,

        /// Sell.
        Sell = 1,

        /// Buy.
        Buy = 2
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Instrument Types.
struct ONIXS_BME_SENAF_EXPORT InstrumentType
{
    /// \copydoc InstrumentType
    enum Enum
    {
        /// Undefined.
        Undefined = 0x0,

        /// Bonds.
        Bonds = 0x1,

        /// Strips.
        Strips = 0x2,

        /// Letras ("Bills").
        Letras = 0x3,

        /// Treasury Repo MEFE (Meffclear-Iberclear).
        TreasuryRepoMEFE = 0x4,

        /// Treasury Repo CNET (Clearnet-Iberclear).
        TreasuryRepoCNET = 0x5,

        /// Repo deliverable.
        RepoDeliverable = 0x6,

        /// Switch.
        Switch = 0x7,

        /// Bilateral Treasury Repo (No CCP-Iberclear).
        BilateralTreasuryRepo = 0x8,

        /// GGB (Government Guaranteed Corporate Bond).
        GGB = 0x9,

        /// Corporate New Issues.
        CorporateNewIssues = 0xA,

        /// Cedulas.
        Cedulas = 0xB,

        /// FROB Bonds.
        FROBBonds = 0xC,

        /// Reserved for other possible Repo instruments.
        /// For instance, GGB Repo MEFE, Treasury Repo LCH (LCH-EuroClear), ...
        Reserved1 = 0x10,

        /// Reserved for other possible Repo instruments.
        /// For instance, GGB Repo MEFE, Treasury Repo LCH (LCH-EuroClear), ...
        Reserved2 = 0x12,

        /// Reserved for other possible Repo instruments.
        /// For instance, GGB Repo MEFE, Treasury Repo LCH (LCH-EuroClear), ...
        Reserved3 = 0x1F
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Confirmation Types.
struct ONIXS_BME_SENAF_EXPORT ConfirmationType
{
    /// \copydoc ConfirmationType
    enum Enum
    {
        /// Undefined.
        Undefined = 0x0,

        /// New.
        New = 0x1,

        /// New Cross Trade.
        NewCrossTrade = 0x2,

        /// Seller rejection.
        SellerRejection = 0x3,

        /// Buyer rejection.
        BuyerRejection = 0x4,

        /// Time to reject expired.
        TimeToRejectExpired = 0x5,

        /// Delivery.
        Delivery = 0x6,

        /// Trade Modification.
        TradeModification = 0x7,

        /// Trade Cancellation.
        TradeCancellation = 0x8
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Trade Status.
struct ONIXS_BME_SENAF_EXPORT TradeStatus
{
    /// \copydoc TradeStatus
    enum Enum
    {
        /// Undefined.
        Undefined = 0x0,

        /// Confirmed.
        Confirmed = 0x1,

        /// Partially Confirmed.
        PartiallyConfirmed = 0x2,

        /// Pending on Delivery.
        PendingOnDelivery = 0x3,

        /// Pending on possible rejection.
        PendingOnPossibleRejection = 0x4,

        /// Rejected.
        Rejected = 0x5,

        /// Modificated.
        Modificated = 0x6,

        /// Cancellated.
        Cancellated = 0x7
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Cash / Term.
struct ONIXS_BME_SENAF_EXPORT CashTerm
{
    /// \copydoc CashTerm
    enum Enum
    {
        /// Undefined.
        Undefined = 0,

        /// Cash.
        Cash = 1,

        /// Term.
        Term = 2
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Delivery restrictions.
struct ONIXS_BME_SENAF_EXPORT DeliveryRestrictions
{
    /// \copydoc DeliveryRestrictions
    enum Enum
    {
        /// No restriction.
        NoRestriction = 0x00,

        /// Not accepted:
        /// - Deliverables with maturity greater than 10 years.
        SUB10 = 0x01,

        /// Not accepted:
        /// - Letras ("Bills").
        NO_LT = 0x02,

        /// Not accepted:
        /// - Deliverables with maturity greater than 10 years.
        /// - Letras ("Bills").
        SUB10_NO_LT = 0x03,

        /// Not accepted:
        /// - Strips.
        NO_ST = 0x04,

        /// Not accepted:
        /// - Deliverables with maturity greater than 10 years.
        /// - Strips.
        SUB10_NO_ST = 0x05,

        /// Not accepted:
        /// - Letras ("Bills").
        /// - Strips.
        NO_LT_NO_ST = 0x06,

        /// Not accepted:
        /// - Deliverables with maturity greater than 10 years.
        /// - Letras ("Bills").
        /// - Strips.
        SUB10_NO_LT_NO_ST = 0x07,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Currency.
struct ONIXS_BME_SENAF_EXPORT Currency
{
    /// \copydoc Currency
    enum Enum
    {
        /// Undefined.
        Undefined = 0x00,

        /// Cents of Euro.
        CentsOfEuro = 0x01,

        /// Cents of Dollar.
        CentsOfDollar = 0x02,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Country.
struct ONIXS_BME_SENAF_EXPORT Country
{
    /// \copydoc Country
    enum Enum
    {
        /// Undefined.
        Undefined = 0x00,

        /// Spain.
        Spain = 0x01,

        /// Germany.
        Germany = 0x02,

        /// Italy.
        Italy = 0x03,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// CCP.
struct ONIXS_BME_SENAF_EXPORT CCP
{
    /// \copydoc CCP
    enum Enum
    {
        /// No CCP.
        NoCCP = 0x00,

        /// BME Clearing.
        BMEClearing = 0x01,

        /// Eurex clearing AG.
        EurexClearingAG = 0x02,

        /// LCH.Clearnet SA.
        LCHClearnetSA = 0x03,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Yield, Price and Cash calculate.
struct ONIXS_BME_SENAF_EXPORT YieldCalculation
{
    /// \copydoc YieldCalculation
    enum Enum
    {
        /// No yield calculation.
        NoYieldCalculation = 0x00,

        /// Recommendation of EFFAS (actual/actual ICMA).
        RecommendationOfEFFAS = 0x01,

        /// True money market.
        TrueMoneyMarket = 0x02,

        /// ISMA.
        ISMA = 0x03,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

/// Leg Number.
struct ONIXS_BME_SENAF_EXPORT LegNumber
{
    /// \copydoc LegNumber
    enum Enum
    {
        /// Undefined.
        Undefined = 0x00,

        /// First Leg.
        FirstLeg = 0x01,

        /// Second Leg.
        SecondLeg = 0x02,
    };

    /// Deserializes constant from string representation.
    static Enum deserialize(const char*);

    /// Returns string representation.
    static const char* toString(Enum);
};

}}}