text:
void generate_class_CTORATstpQryConversionBondInfoField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryConversionBondInfoField> c(parent, "CTORATstpQryConversionBondInfoField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryConversionBondInfoField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryConversionBondInfoField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryConversionBondInfoField, "SecurityID", SecurityID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryConversionBondInfoField, c);
    module_vntora::objects.emplace("CTORATstpQryConversionBondInfoField", c);
}
void generate_class_CTORATstpConversionBondInfoField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpConversionBondInfoField> c(parent, "CTORATstpConversionBondInfoField");
    if constexpr (std::is_default_constructible_v<CTORATstpConversionBondInfoField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ConvertOrderID", ConvertOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ConvertPrice", ConvertPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ConvertVolUnit", ConvertVolUnit);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ConvertVolMax", ConvertVolMax);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "ConvertVolMin", ConvertVolMin);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "BeginDate", BeginDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "EndDate", EndDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpConversionBondInfoField, "IsSupportCancel", IsSupportCancel);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpConversionBondInfoField, c);
    module_vntora::objects.emplace("CTORATstpConversionBondInfoField", c);
}
void generate_class_CTORATstpQryBondPutbackInfoField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryBondPutbackInfoField> c(parent, "CTORATstpQryBondPutbackInfoField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryBondPutbackInfoField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryBondPutbackInfoField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryBondPutbackInfoField, "SecurityID", SecurityID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryBondPutbackInfoField, c);
    module_vntora::objects.emplace("CTORATstpQryBondPutbackInfoField", c);
}
void generate_class_CTORATstpBondPutbackInfoField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpBondPutbackInfoField> c(parent, "CTORATstpBondPutbackInfoField");
    if constexpr (std::is_default_constructible_v<CTORATstpBondPutbackInfoField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "PutbackOrderID", PutbackOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "PutbackPrice", PutbackPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "PutbackVolUnit", PutbackVolUnit);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "PutbackVolMax", PutbackVolMax);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "PutbackVolMin", PutbackVolMin);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "BeginDate", BeginDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "EndDate", EndDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBondPutbackInfoField, "IsSupportCancel", IsSupportCancel);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpBondPutbackInfoField, c);
    module_vntora::objects.emplace("CTORATstpBondPutbackInfoField", c);
}
void generate_class_CTORATstpQryStandardBondPositionField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryStandardBondPositionField> c(parent, "CTORATstpQryStandardBondPositionField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryStandardBondPositionField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryStandardBondPositionField, "BusinessUnitID", BusinessUnitID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryStandardBondPositionField, c);
    module_vntora::objects.emplace("CTORATstpQryStandardBondPositionField", c);
}
void generate_class_CTORATstpStandardBondPositionField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpStandardBondPositionField> c(parent, "CTORATstpStandardBondPositionField");
    if constexpr (std::is_default_constructible_v<CTORATstpStandardBondPositionField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "TradingDay", TradingDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "AvailablePosition", AvailablePosition);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "AvailablePosFrozen", AvailablePosFrozen);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpStandardBondPositionField, "TotalPosition", TotalPosition);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpStandardBondPositionField, c);
    module_vntora::objects.emplace("CTORATstpStandardBondPositionField", c);
}
void generate_class_CTORATstpQryDesignationRegistrationField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryDesignationRegistrationField> c(parent, "CTORATstpQryDesignationRegistrationField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryDesignationRegistrationField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "OrderSysID", OrderSysID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "InsertTimeStart", InsertTimeStart);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "InsertTimeEnd", InsertTimeEnd);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryDesignationRegistrationField, "BusinessUnitID", BusinessUnitID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryDesignationRegistrationField, c);
    module_vntora::objects.emplace("CTORATstpQryDesignationRegistrationField", c);
}
void generate_class_CTORATstpDesignationRegistrationField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpDesignationRegistrationField> c(parent, "CTORATstpDesignationRegistrationField");
    if constexpr (std::is_default_constructible_v<CTORATstpDesignationRegistrationField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "UserID", UserID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "DesignationType", DesignationType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "OrderLocalID", OrderLocalID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "PbuID", PbuID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "OrderSubmitStatus", OrderSubmitStatus);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "TradingDay", TradingDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "OrderSysID", OrderSysID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "OrderStatus", OrderStatus);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "InsertDate", InsertDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "InsertTime", InsertTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "StatusMsg", StatusMsg);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "AccountID", AccountID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "CurrencyID", CurrencyID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpDesignationRegistrationField, "DepartmentID", DepartmentID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpDesignationRegistrationField, c);
    module_vntora::objects.emplace("CTORATstpDesignationRegistrationField", c);
}
void generate_class_CTORATstpQryCustodyTransferField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryCustodyTransferField> c(parent, "CTORATstpQryCustodyTransferField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryCustodyTransferField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "OrderSysID", OrderSysID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "InsertTimeStart", InsertTimeStart);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "InsertTimeEnd", InsertTimeEnd);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCustodyTransferField, "SecurityID", SecurityID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryCustodyTransferField, c);
    module_vntora::objects.emplace("CTORATstpQryCustodyTransferField", c);
}
void generate_class_CTORATstpCustodyTransferField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpCustodyTransferField> c(parent, "CTORATstpCustodyTransferField");
    if constexpr (std::is_default_constructible_v<CTORATstpCustodyTransferField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "UserID", UserID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "CustodyTransferType", CustodyTransferType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "OrderLocalID", OrderLocalID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "PbuID", PbuID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "OrderSubmitStatus", OrderSubmitStatus);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "TradingDay", TradingDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "OrderSysID", OrderSysID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "OrderStatus", OrderStatus);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "InsertDate", InsertDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "InsertTime", InsertTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "StatusMsg", StatusMsg);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "AccountID", AccountID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "CurrencyID", CurrencyID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "DepartmentID", DepartmentID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "TransfereePbuID", TransfereePbuID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "OrignalOrderLocalID", OrignalOrderLocalID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "VolumeTotalOriginal", VolumeTotalOriginal);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "CancelTime", CancelTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "ActiveTraderID", ActiveTraderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCustodyTransferField, "ActiveUserID", ActiveUserID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpCustodyTransferField, c);
    module_vntora::objects.emplace("CTORATstpCustodyTransferField", c);
}
void generate_class_CTORATstpQrySpecialMarketDataField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQrySpecialMarketDataField> c(parent, "CTORATstpQrySpecialMarketDataField");
    if constexpr (std::is_default_constructible_v<CTORATstpQrySpecialMarketDataField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQrySpecialMarketDataField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQrySpecialMarketDataField, "ExchangeID", ExchangeID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQrySpecialMarketDataField, c);
    module_vntora::objects.emplace("CTORATstpQrySpecialMarketDataField", c);
}
void generate_class_CTORATstpSpecialMarketDataField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpSpecialMarketDataField> c(parent, "CTORATstpSpecialMarketDataField");
    if constexpr (std::is_default_constructible_v<CTORATstpSpecialMarketDataField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "TradingDay", TradingDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "SecurityName", SecurityName);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "MovingAvgPrice", MovingAvgPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "MovingAvgPriceSamplingNum", MovingAvgPriceSamplingNum);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "UpdateTime", UpdateTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpSpecialMarketDataField, "UpdateMillisec", UpdateMillisec);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpSpecialMarketDataField, c);
    module_vntora::objects.emplace("CTORATstpSpecialMarketDataField", c);
}
void generate_class_CTORATstpQryPrematurityRepoOrderField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryPrematurityRepoOrderField> c(parent, "CTORATstpQryPrematurityRepoOrderField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryPrematurityRepoOrderField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "OrderLocalID", OrderLocalID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "ProductID", ProductID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "Direction", Direction);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPrematurityRepoOrderField, "TradeID", TradeID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryPrematurityRepoOrderField, c);
    module_vntora::objects.emplace("CTORATstpQryPrematurityRepoOrderField", c);
}
void generate_class_CTORATstpPrematurityRepoOrderField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpPrematurityRepoOrderField> c(parent, "CTORATstpPrematurityRepoOrderField");
    if constexpr (std::is_default_constructible_v<CTORATstpPrematurityRepoOrderField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "TradeDay", TradeDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "ExpireDay", ExpireDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "OrderLocalID", OrderLocalID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "SecurityName", SecurityName);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "ProductID", ProductID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "Direction", Direction);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "VolumeTraded", VolumeTraded);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "Price", Price);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "Turnover", Turnover);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "TradeID", TradeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "RepoTotalMoney", RepoTotalMoney);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpPrematurityRepoOrderField, "InterestAmount", InterestAmount);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpPrematurityRepoOrderField, c);
    module_vntora::objects.emplace("CTORATstpPrematurityRepoOrderField", c);
}
void generate_class_CTORATstpQryShareholderParamField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryShareholderParamField> c(parent, "CTORATstpQryShareholderParamField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryShareholderParamField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "TradingCodeClass", TradingCodeClass);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "ProductID", ProductID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "ParamType", ParamType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryShareholderParamField, "ExchangeID", ExchangeID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryShareholderParamField, c);
    module_vntora::objects.emplace("CTORATstpQryShareholderParamField", c);
}
void generate_class_CTORATstpShareholderParamField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpShareholderParamField> c(parent, "CTORATstpShareholderParamField");
    if constexpr (std::is_default_constructible_v<CTORATstpShareholderParamField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "MarketID", MarketID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "TradingCodeClass", TradingCodeClass);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "ProductID", ProductID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "ParamType", ParamType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpShareholderParamField, "ParamValue", ParamValue);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpShareholderParamField, c);
    module_vntora::objects.emplace("CTORATstpShareholderParamField", c);
}
void generate_class_CTORATstpQryPeripheryPositionTransferDetailField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryPeripheryPositionTransferDetailField> c(parent, "CTORATstpQryPeripheryPositionTransferDetailField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryPeripheryPositionTransferDetailField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, "TransferDirection", TransferDirection);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, "BusinessUnitID", BusinessUnitID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryPeripheryPositionTransferDetailField, c);
    module_vntora::objects.emplace("CTORATstpQryPeripheryPositionTransferDetailField", c);
}
void generate_class_CTORATstpQryInvestorCondOrderLimitParamField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryInvestorCondOrderLimitParamField> c(parent, "CTORATstpQryInvestorCondOrderLimitParamField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryInvestorCondOrderLimitParamField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryInvestorCondOrderLimitParamField, "InvestorID", InvestorID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryInvestorCondOrderLimitParamField, c);
    module_vntora::objects.emplace("CTORATstpQryInvestorCondOrderLimitParamField", c);
}
void generate_class_CTORATstpInvestorCondOrderLimitParamField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpInvestorCondOrderLimitParamField> c(parent, "CTORATstpInvestorCondOrderLimitParamField");
    if constexpr (std::is_default_constructible_v<CTORATstpInvestorCondOrderLimitParamField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpInvestorCondOrderLimitParamField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpInvestorCondOrderLimitParamField, "MaxCondOrderLimitCnt", MaxCondOrderLimitCnt);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpInvestorCondOrderLimitParamField, "CurrCondOrderCnt", CurrCondOrderCnt);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpInvestorCondOrderLimitParamField, c);
    module_vntora::objects.emplace("CTORATstpInvestorCondOrderLimitParamField", c);
}
void generate_class_CTORATstpQryCondOrderField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryCondOrderField> c(parent, "CTORATstpQryCondOrderField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryCondOrderField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "CondOrderID", CondOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "InsertTimeStart", InsertTimeStart);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "InsertTimeEnd", InsertTimeEnd);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "BInfo", BInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "SInfo", SInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderField, "IInfo", IInfo);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryCondOrderField, c);
    module_vntora::objects.emplace("CTORATstpQryCondOrderField", c);
}
void generate_class_CTORATstpCondOrderField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpCondOrderField> c(parent, "CTORATstpCondOrderField");
    if constexpr (std::is_default_constructible_v<CTORATstpCondOrderField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "Direction", Direction);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "OrderPriceType", OrderPriceType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "OrderVolumeType", OrderVolumeType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "TimeCondition", TimeCondition);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "VolumeCondition", VolumeCondition);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "LimitPrice", LimitPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "VolumeTotalOriginal", VolumeTotalOriginal);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CombOffsetFlag", CombOffsetFlag);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CombHedgeFlag", CombHedgeFlag);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CondOrderRef", CondOrderRef);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AccountID", AccountID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "UserID", UserID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "RequestID", RequestID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "IPAddress", IPAddress);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "MacAddress", MacAddress);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CondOrderID", CondOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "TerminalInfo", TerminalInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "BInfo", BInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "SInfo", SInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "IInfo", IInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "Operway", Operway);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CondCheck", CondCheck);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ContingentCondition", ContingentCondition);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ConditionPrice", ConditionPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "PriceTicks", PriceTicks);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "VolumeMultiple", VolumeMultiple);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "RelativeFrontID", RelativeFrontID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "RelativeSessionID", RelativeSessionID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "RelativeParam", RelativeParam);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AppendContingentCondition", AppendContingentCondition);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AppendConditionPrice", AppendConditionPrice);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AppendRelativeFrontID", AppendRelativeFrontID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AppendRelativeSessionID", AppendRelativeSessionID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "AppendRelativeParam", AppendRelativeParam);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "TradingDay", TradingDay);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CondOrderStatus", CondOrderStatus);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "InsertDate", InsertDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "InsertTime", InsertTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CancelTime", CancelTime);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "CancelUser", CancelUser);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "FrontID", FrontID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "SessionID", SessionID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "UserProductInfo", UserProductInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "StatusMsg", StatusMsg);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "DepartmentID", DepartmentID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ProperCtrlBusinessType", ProperCtrlBusinessType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ProperCtrlPassFlag", ProperCtrlPassFlag);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ActiveDate", ActiveDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderField, "ActiveTime", ActiveTime);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpCondOrderField, c);
    module_vntora::objects.emplace("CTORATstpCondOrderField", c);
}
void generate_class_CTORATstpQryCondOrderActionField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryCondOrderActionField> c(parent, "CTORATstpQryCondOrderActionField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryCondOrderActionField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "BInfo", BInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "SInfo", SInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryCondOrderActionField, "IInfo", IInfo);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryCondOrderActionField, c);
    module_vntora::objects.emplace("CTORATstpQryCondOrderActionField", c);
}
void generate_class_CTORATstpCondOrderActionField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpCondOrderActionField> c(parent, "CTORATstpCondOrderActionField");
    if constexpr (std::is_default_constructible_v<CTORATstpCondOrderActionField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "RequestID", RequestID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "CondOrderActionRef", CondOrderActionRef);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "CondOrderRef", CondOrderRef);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "FrontID", FrontID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "SessionID", SessionID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "CondOrderID", CondOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "ActionFlag", ActionFlag);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "UserID", UserID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "CancelCondOrderID", CancelCondOrderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "IPAddress", IPAddress);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "MacAddress", MacAddress);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "TerminalInfo", TerminalInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "BInfo", BInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "SInfo", SInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "IInfo", IInfo);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "Operway", Operway);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "BusinessUnitID", BusinessUnitID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "ActionDate", ActionDate);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpCondOrderActionField, "ActionTime", ActionTime);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpCondOrderActionField, c);
    module_vntora::objects.emplace("CTORATstpCondOrderActionField", c);
}
void generate_class_CTORATstpQryBrokerUserRoleField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryBrokerUserRoleField> c(parent, "CTORATstpQryBrokerUserRoleField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryBrokerUserRoleField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryBrokerUserRoleField, "RoleID", RoleID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryBrokerUserRoleField, c);
    module_vntora::objects.emplace("CTORATstpQryBrokerUserRoleField", c);
}
void generate_class_CTORATstpBrokerUserRoleField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpBrokerUserRoleField> c(parent, "CTORATstpBrokerUserRoleField");
    if constexpr (std::is_default_constructible_v<CTORATstpBrokerUserRoleField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleField, "RoleID", RoleID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleField, "RoleDescription", RoleDescription);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleField, "Functions", Functions);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpBrokerUserRoleField, c);
    module_vntora::objects.emplace("CTORATstpBrokerUserRoleField", c);
}
void generate_class_CTORATstpQryBrokerUserRoleAssignmentField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryBrokerUserRoleAssignmentField> c(parent, "CTORATstpQryBrokerUserRoleAssignmentField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryBrokerUserRoleAssignmentField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryBrokerUserRoleAssignmentField, "UserID", UserID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryBrokerUserRoleAssignmentField, c);
    module_vntora::objects.emplace("CTORATstpQryBrokerUserRoleAssignmentField", c);
}
void generate_class_CTORATstpBrokerUserRoleAssignmentField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpBrokerUserRoleAssignmentField> c(parent, "CTORATstpBrokerUserRoleAssignmentField");
    if constexpr (std::is_default_constructible_v<CTORATstpBrokerUserRoleAssignmentField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleAssignmentField, "UserID", UserID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleAssignmentField, "RoleID", RoleID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpBrokerUserRoleAssignmentField, "RoleDescription", RoleDescription);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpBrokerUserRoleAssignmentField, c);
    module_vntora::objects.emplace("CTORATstpBrokerUserRoleAssignmentField", c);
}
void generate_class_CTORATstpQryTradingNoticeField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryTradingNoticeField> c(parent, "CTORATstpQryTradingNoticeField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryTradingNoticeField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryTradingNoticeField, "InvestorID", InvestorID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryTradingNoticeField, "InsertDateStart", InsertDateStart);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryTradingNoticeField, "InsertDateEnd", InsertDateEnd);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryTradingNoticeField, "InsertTimeStart", InsertTimeStart);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryTradingNoticeField, "InsertTimeEnd", InsertTimeEnd);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryTradingNoticeField, c);
    module_vntora::objects.emplace("CTORATstpQryTradingNoticeField", c);
}
void generate_class_CTORATstpQryIPONumberResultField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryIPONumberResultField> c(parent, "CTORATstpQryIPONumberResultField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryIPONumberResultField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPONumberResultField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPONumberResultField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPONumberResultField, "ShareholderID", ShareholderID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryIPONumberResultField, c);
    module_vntora::objects.emplace("CTORATstpQryIPONumberResultField", c);
}
void generate_class_CTORATstpIPONumberResultField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpIPONumberResultField> c(parent, "CTORATstpIPONumberResultField");
    if constexpr (std::is_default_constructible_v<CTORATstpIPONumberResultField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "Day", Day);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "SecurityName", SecurityName);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "BeginNumberID", BeginNumberID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPONumberResultField, "Volume", Volume);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpIPONumberResultField, c);
    module_vntora::objects.emplace("CTORATstpIPONumberResultField", c);
}
void generate_class_CTORATstpQryIPOMatchNumberResultField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpQryIPOMatchNumberResultField> c(parent, "CTORATstpQryIPOMatchNumberResultField");
    if constexpr (std::is_default_constructible_v<CTORATstpQryIPOMatchNumberResultField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPOMatchNumberResultField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPOMatchNumberResultField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPOMatchNumberResultField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpQryIPOMatchNumberResultField, "MatchNumberID", MatchNumberID);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpQryIPOMatchNumberResultField, c);
    module_vntora::objects.emplace("CTORATstpQryIPOMatchNumberResultField", c);
}
void generate_class_CTORATstpIPOMatchNumberResultField(pybind11::object & parent)
{
    pybind11::class_<CTORATstpIPOMatchNumberResultField> c(parent, "CTORATstpIPOMatchNumberResultField");
    if constexpr (std::is_default_constructible_v<CTORATstpIPOMatchNumberResultField>)
        c.def(pybind11::init<>());
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "ExchangeID", ExchangeID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "SecurityID", SecurityID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "Day", Day);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "SecurityName", SecurityName);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "ShareholderID", ShareholderID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "SecurityType", SecurityType);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "MatchNumberID", MatchNumberID);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "Volume", Volume);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "Price", Price);
    c.AUTOCXXPY_DEF_PROPERTY(tag_vntora, CTORATstpIPOMatchNumberResultField, "Amout", Amout);
    AUTOCXXPY_POST_REGISTER_CLASS(tag_vntora, CTORATstpIPOMatchNumberResultField, c);
    module_vntora::objects.emplace("CTORATstpIPOMatchNumberResultField", c);
}


text:
define([
    './basemap-gallery'
], function (basemapGallery) {

	var context;

	var exposed = {
        init: function(thisContext) {
            context = thisContext;
            context.sandbox.on('basemapGallery.close', basemapGallery.hide);
            context.sandbox.on('basemapGallery.open', basemapGallery.show);
            context.sandbox.on('map.basemap.change', basemapGallery.changeBasemap);
        },
        changeBasemap: function(params) {
            context.sandbox.emit('map.basemap.change', params);
        },
        openBasemapGallery: function() {
            context.sandbox.emit('basemapGallery.open');
        },
        closeBasemapGAllery: function() {
            context.sandbox.emit('basemapGallery.close');
        }
    };

    return exposed;

});

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Threading;
using System.Threading.Tasks;

namespace Resonance.Data.Storage
{
    public class RepositoryCacheDelegate<T> : IRepositoryCacheDelegate<T>
    {
        public Func<CancellationToken, Task<T>> Method { get; set; }

        public virtual Task<T> GetResult(CancellationToken cancellationToken)
        {
            return Method(cancellationToken);
        }
    }
}


text:
[Jedisjeux](https://www.jedisjeux.net) is a PHP boardgame website, based on [Symfony Framework](http://symfony.com/) and [Sylius](http://sylius.org/).

Documentation
-------------

Documentation is available at [docs.jedisjeux.net](https://jedisjeux.readthedocs.io/en/latest/).

Installation
------------

You need [composer](https://getcomposer.org/doc/00-intro.md#installation-linux-unix-osx) to install PHP packages and [yarn](https://yarnpkg.com/lang/en/docs/install/) to install JS packages.

```bash
$ php bin/console app:install
$ yarn install && yarn run gulp
$ php bin/console server:start
```

Then open `http://localhost:8000/` in your web browser to enjoy Jedisjeux website in a development environment.

[Behat](http://behat.org) scenarios
-----------------------------------

By default Behat uses `http://localhost:8080/` as your application base url. If your one is different,
you need to create `behat.yml` files that will overwrite it with your custom url:

```yaml
imports: ["behat.yml.dist"]

default:
    extensions:
        Behat\MinkExtension:
            base_url: http://my.custom.url
```

Then run selenium-server-standalone:

```bash
$ bin/selenium-server-standalone -Dwebdriver.chrome.driver=$PWD/bin/chromedriver
```

Then setup your test database:

```bash
$ php bin/console doctrine:database:create --env=test
$ php bin/console doctrine:schema:create --env=test
$ php bin/console cache:clear --no-warmup --env=test
$ php bin/console doctrine:phpcr:repository:init --env=test
```

You can run Behat using the following commands:

```bash
$ vendor/bin/behat
```

Bug Tracking
------------

If you want to report a bug or suggest an idea, please use [GitHub issues](https://github.com/Jedisjeux/Jedisjeux/issues).

MIT License
-----------

Jedisjeux is completely free and released under the [MIT License](https://github.com/Jedisjeux/Jedisjeux/blob/master/LICENSE).

Authors
-------

Jedisjeux was originally created by Loïc Frémont.
See the list of [contributors from our community](https://github.com/Jedisjeux/Jedisjeux/contributors).


text:
{-# LANGUAGE RankNTypes, NoMonomorphismRestriction, BangPatterns #-}

module Main where

import Data.List
import Data.Dynamic
import System.Directory
import System.IO
import System.Environment (getArgs, getProgName)
import System.Exit (exitFailure)
import Text.Parsec

import qualified Data.Map.Strict as M
import qualified Data.Number.LogFloat as LF

import Mixture (Prob, empty, point, Mixture(..), mnull)
import Types (Cond(..), CSampler)
import InterpreterDynamic
import Lambda (dbl)

-- particle filtering
onlineFiltering :: (Ord a, Show a) =>
                   (Mixture a -> Double -> Double -> Double -> Measure a) ->
                   Mixture a ->
                   [[Cond]] ->
				   Int ->
				   Double ->
				   Double ->
				   Double ->
                   IO (Mixture a)
onlineFiltering _ prior [] _ _ _ _ = return prior
onlineFiltering prog prior (cond:conds) n x y t = do
  let curTime = convertTime (head cond)
  let timeElapsed = curTime - t
  posterior <- sample n (prog prior x y timeElapsed) (tail cond)
  let mixtureList = M.toAscList (unMixture posterior)
  let outputList = foldl (\acc (k, v) -> [(k, LF.fromLogFloat(v)::Double)] ++ acc) [] mixtureList
  let (k, w) = head $ sortMix outputList
  let output = removeBrackets (if null mixtureList then "" else (show (curTime, k, w) ++ "\n"))
  appendFile "slam_out_data.csv" output
  onlineFiltering prog posterior conds n x y curTime

-- quad rotor model (kalman filter)
prog_quadCopter :: Mixture (Double, Double, Double, Double) ->
                   Double ->
                   Double ->
                   Double ->
                   Measure (Double, Double, Double, Double)
prog_quadCopter prevMix initX initY timeElapsed = do
  velocity <- conditioned (uniform (dbl 0) (dbl 5))
  steerAngle <- conditioned (uniform (dbl (-2)) (dbl 2))
  (x0, y0, dirX, dirY) <- if mnull prevMix then return (initX, initY, 0, 1)
  else unconditioned (categorical (M.toList(unMixture prevMix)))
  let orientX = dirX * cos (-1 * steerAngle) - dirY * sin (-1 * steerAngle)
  let orientY = dirY * cos (-1 * steerAngle) + dirX * sin (-1 * steerAngle)
  x1 <- unconditioned (normal (x0 + orientX * velocity*timeElapsed) (dbl 7))
  y1 <- unconditioned (normal (y0 + orientY * velocity*timeElapsed) (dbl 7))
  _ <- conditioned (normal (x1 :: Double) (dbl 1))
  _ <- conditioned (normal (y1 :: Double) (dbl 1))
  return (x1, y1, orientX, orientY)

-- helper functions
compareMix (_, v1) (_, v2) = if (v1 < v2) then GT
  else LT

sortMix = sortBy compareMix

csvFile = endBy line eol
line = sepBy cell (char ',')
cell = many (noneOf ",\n")
eol = char '\n'

parseCSV :: String -> Either ParseError [[String]]
parseCSV input = parse csvFile "(unknown)" input

removeBrackets :: String -> String
removeBrackets st = [c | c <- st, c `notElem` ['(', ')']]

convertTime :: Cond -> Double
convertTime (Lebesgue t) = case fromDynamic t of
  Just t -> t
  Nothing -> error "Not conditioned data"
convertTime (Discrete t) = case fromDynamic t of
  Just t -> t
  Nothing -> error "Not conditioned data"
convertTime (Unconditioned) = 0.0

convertC :: Either ParseError [[String]] -> [[Cond]]
convertC (Left _) = [[]]
convertC (Right s) = map (\x0 -> map (\x1 ->Lebesgue (toDyn(read x1::Double))) x0) (s)

convertS :: Either ParseError [[String]] -> [[String]]
convertS (Left _) = [[]]
convertS (Right s) = s

convertD :: [[String]] -> [[Double]]
convertD str = map (\x0 -> map (\x1 -> read x1 :: Double) x0) str

convertTable :: [[String]] -> [String]
convertTable table = foldl (\acc x -> acc ++ [convertCSV x (head x)]) [] table

convertCSV :: [String] -> String -> String
convertCSV list firstElement = foldl (\acc x -> if (x == firstElement) then acc ++ x
  else acc ++ "," ++ x) "" list

mergeGPS :: [Double] -> [Double] -> [[Double]] -> Int -> [[String]] -> [[String]]
mergeGPS _ _ _ 0 list = list
mergeGPS time_g time_r results n list =
  mergeGPS time_g time_r results (n - 1)
  (if (time_r !! n) `elem` time_g  then
   [[show (time_r !! n), show ((results !! n) !! 1), show ((results !! n) !! 2)]] ++ list else list)

-- main program
main :: IO ()
main = do
  args <- getArgs
  writeFile "slam_out_landmarks.csv" ""
  case args of
    [numParticles, x, y] -> do
      handle <- openFile "output.csv" ReadMode
      contents <- hGetContents handle
      let cond = convertS (parseCSV contents)
      print ((show (length cond)) ++ " row(s)")
      print ((show (length (head cond))) ++ " column(s)")
      let condInput = convertC (parseCSV contents)
      -- ignore orientation column
      let condInputFix = transpose (init (transpose condInput))
      exist <- doesFileExist "slam_out_data.csv"
      if exist then removeFile "slam_out_data.csv" else return ()
      output <- onlineFiltering prog_quadCopter empty condInputFix
                  (read numParticles :: Int)
	              (read x :: Double) (read y :: Double) 0.0
      putStrLn (show output)
    _ -> do
	  progName <- getProgName
	  hPutStrLn stderr ("Usage: " ++ progName ++
	    " <number of particles> <initial latitude> <initial longitude>")
	  hPutStrLn stderr ("Example: " ++ progName ++ " 30 0 -6")
	  exitFailure
  gps_contents <- readFile "slam_gps.csv"
  let gps = tail (convertD (convertS (parseCSV gps_contents)))
  let gps_c = head (transpose gps)
  results_contents <- readFile "slam_out_data.csv"
  let results = convertD (convertS (parseCSV results_contents))
  let results_c = head (transpose results)
  let slam_output = mergeGPS gps_c results_c results ((length results) - 1) [[]]
  writeFile "slam_out_path.csv" (show (head (head gps)) ++ "," ++
    show ((head gps) !! 1) ++ "," ++ show ((head gps) !! 2) ++ "\n")
  appendFile "slam_out_path.csv" (unlines (convertTable slam_output))
  putStrLn "Output written to slam_out_path.csv"


text:
/*
 * $Id: DCPSInfo_i.h 6633 2014-12-04 07:05:56Z fields_t $
 *
 *
 * Distributed under the OpenDDS License.
 * See: http://www.opendds.org/license.html
 */

#ifndef DCPSINFO_I_H
#define DCPSINFO_I_H

#include  "inforepo_export.h"
#include /**/ "DCPS_IR_Topic.h"
#include /**/ "DCPS_IR_Topic_Description.h"
#include /**/ "DCPS_IR_Participant.h"
#include /**/ "DCPS_IR_Publication.h"
#include /**/ "DCPS_IR_Subscription.h"
#include /**/ "DCPS_IR_Domain.h"
#include "dds/DCPS/RepoIdGenerator.h"
#include "FederationId.h"
#include "UpdateManager.h"

#include /**/ "dds/DCPS/InfoRepoDiscovery/InfoS.h"
#include /**/ "dds/DCPS/InfoRepoDiscovery/DataReaderRemoteC.h"
#include /**/ "dds/DCPS/InfoRepoDiscovery/DataWriterRemoteC.h"

#include "tao/ORB_Core.h"

#include <map>

#if !defined (ACE_LACKS_PRAGMA_ONCE)
#pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

// typedef declarations
typedef std::map<DDS::DomainId_t, DCPS_IR_Domain*> DCPS_IR_Domain_Map;

// Forward declaration
namespace Update {
class Manager;
}

class ShutdownInterface;

/**
 * @class TAO_DDS_DCPSInfo_i
 *
 * @brief Implementation of the DCPSInfo
 *
 * This is the Information Repository object.  Clients of
 * the system will use the CORBA reference of this object.
 */
class  OpenDDS_InfoRepoLib_Export TAO_DDS_DCPSInfo_i
  : public virtual POA_OpenDDS::DCPS::DCPSInfo,
    public ACE_Event_Handler {
public:
  //Constructor
  TAO_DDS_DCPSInfo_i(
    CORBA::ORB_ptr orb,
    bool reincarnate,
    ShutdownInterface* shutdown,
    const TAO_DDS_DCPSFederationId& federation);

  //Destructor
  virtual ~TAO_DDS_DCPSInfo_i();

  virtual int handle_timeout(const ACE_Time_Value& now,
                             const void* arg);

  virtual CORBA::Boolean attach_participant(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId);

  virtual OpenDDS::DCPS::TopicStatus assert_topic(
    OpenDDS::DCPS::RepoId_out topicId,
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const char * topicName,
    const char * dataTypeName,
    const DDS::TopicQos & qos,
    bool hasDcpsKey);

  /**
   * @brief Add a previously existing topic to the repository.
   *
   * @param topicId       the Topic Entity GUID Id to use.
   * @param domainId      the Domain in which the Topic is contained.
   * @param participantId the Participant in which the Topic is contained.
   * @param topicName     the name of the Topic.
   * @param dataTypeName  the name of the data type.
   * @param qos           the QoS value to use for the Topic.
   *
   * Adds a Topic Entity to the repository using a specified TopicId
   * value.  If the TopicId indicates that this Topic was created by
   * within this repository (the federation Id is the current repositories
   * federation Id), this method will ensure that any subsequent calls to
   * add a Topic and obtain a newly generated Id value will return an Id
   * value greater than the Id value of the current one.
   */
  bool add_topic(const OpenDDS::DCPS::RepoId& topicId,
                 DDS::DomainId_t domainId,
                 const OpenDDS::DCPS::RepoId& participantId,
                 const char* topicName,
                 const char* dataTypeName,
                 const DDS::TopicQos& qos);

  virtual OpenDDS::DCPS::TopicStatus find_topic(
    DDS::DomainId_t domainId,
    const char * topicName,
    CORBA::String_out dataTypeName,
    DDS::TopicQos_out qos,
    OpenDDS::DCPS::RepoId_out topicId);

  virtual OpenDDS::DCPS::TopicStatus remove_topic(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& topicId);

  virtual OpenDDS::DCPS::RepoId add_publication(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& topicId,
    OpenDDS::DCPS::DataWriterRemote_ptr publication,
    const DDS::DataWriterQos & qos,
    const OpenDDS::DCPS::TransportLocatorSeq & transInfo,
    const DDS::PublisherQos & publisherQos);

  /**
   * @brief Add a previously existing publication to the repository.
   *
   * @param domainId      the Domain in which the Publication is contained.
   * @param participantId the Participant in which the Publication is contained.
   * @param topicId       the Topic of the Publication.
   * @param pubId         the GUID Id value to use for the Publication.
   * @param pub_str       stringified publication callback to DataWriter.
   * @param qos           the QoS value of the DataWriter.
   * @param transInfo     the transport information for the Publication.
   * @param publisherQos  the QoS value of the Publisher.
   * @param associate     indicate whether to create new associations.
   *
   * Adds a Publication to the repository using a specified Publication
   * GUID Id value.  If the PublicationId indicates that this Publication
   * was created by within this repository (the federation Id is the
   * current repositories federation Id), this method will ensure that any
   * subsequent calls to add a Publication and obtain a newly generated
   * Id value will return an Id value greater than the Id value of the
   * current one.
   */
  bool add_publication(DDS::DomainId_t domainId,
                       const OpenDDS::DCPS::RepoId& participantId,
                       const OpenDDS::DCPS::RepoId& topicId,
                       const OpenDDS::DCPS::RepoId& pubId,
                       const char* pub_str,
                       const DDS::DataWriterQos & qos,
                       const OpenDDS::DCPS::TransportLocatorSeq & transInfo,
                       const DDS::PublisherQos & publisherQos,
                       bool associate = false);

  virtual void remove_publication(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& publicationId);

  virtual OpenDDS::DCPS::RepoId add_subscription(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& topicId,
    OpenDDS::DCPS::DataReaderRemote_ptr subscription,
    const DDS::DataReaderQos & qos,
    const OpenDDS::DCPS::TransportLocatorSeq & transInfo,
    const DDS::SubscriberQos & subscriberQos,
    const char* filterExpression,
    const DDS::StringSeq& exprParams);

  /**
   * @brief Add a previously existing subscription to the repository.
   *
   * @param domainId      the Domain in which the Subscription is contained.
   * @param participantId the Participant in which the Subscription is contained.
   * @param topicId       the Topic of the Subscription.
   * @param subId         the GUID Id value to use for the Subscription.
   * @param sub_str       stringified publication callback to DataReader.
   * @param qos           the QoS value of the DataReader.
   * @param transInfo     the transport information for the Subscription.
   * @param subscriberQos the QoS value of the Subscriber.
   * @param associate     indicate whether to create new associations.
   *
   * Adds a Subscription to the repository using a specified Subscription
   * GUID Id value.  If the SubscriptionId indicates that this Subscription
   * was created by within this repository (the federation Id is the
   * current repositories federation Id), this method will ensure that any
   * subsequent calls to add a Publication and obtain a newly generated
   * Id value will return an Id value greater than the Id value of the
   * current one.
   */
  bool add_subscription(DDS::DomainId_t domainId,
                        const OpenDDS::DCPS::RepoId& participantId,
                        const OpenDDS::DCPS::RepoId& topicId,
                        const OpenDDS::DCPS::RepoId& subId,
                        const char* sub_str,
                        const DDS::DataReaderQos & qos,
                        const OpenDDS::DCPS::TransportLocatorSeq & transInfo,
                        const DDS::SubscriberQos & subscriberQos,
                        const char* filterExpression,
                        const DDS::StringSeq& exprParams,
                        bool associate = false);

  virtual void remove_subscription(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& subscriptionId);

  virtual OpenDDS::DCPS::AddDomainStatus add_domain_participant(
    DDS::DomainId_t domain,
    const DDS::DomainParticipantQos & qos);

  /**
   * @brief Add a previously existing participant to the repository.
   *
   * @param domainId      the Domain in which the Participant is contained.
   * @param participantId the GUID Id value to use for the Participant.
   * @param qos           the QoS value of the Participant.
   *
   * Adds a Participant to the repository using a specified Participant
   * GUID Id value.  If the ParticipantId indicates that this Participant
   * was created by within this repository (the federation Id is the
   * current repositories federation Id), this method will ensure that any
   * subsequent calls to add a Publication and obtain a newly generated
   * Id value will return an Id value greater than the Id value of the
   * current one.
   */
  bool add_domain_participant(DDS::DomainId_t domainId
                              , const OpenDDS::DCPS::RepoId& participantId
                              , const DDS::DomainParticipantQos & qos);

  virtual void remove_domain_participant(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId);

  virtual void association_complete(DDS::DomainId_t domainId,
                                    const OpenDDS::DCPS::RepoId& participantId,
                                    const OpenDDS::DCPS::RepoId& localId,
                                    const OpenDDS::DCPS::RepoId& remoteId);

  bool remove_by_owner(
    DDS::DomainId_t domain,
    long              owner);

  virtual void disassociate_participant(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& local_id,
    const OpenDDS::DCPS::RepoId& remote_id);

  virtual void disassociate_subscription(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& local_id,
    const OpenDDS::DCPS::RepoId& remote_id);

  virtual void disassociate_publication(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& local_id,
    const OpenDDS::DCPS::RepoId& remote_id);

  virtual void ignore_domain_participant(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& myParticipantId,
    const OpenDDS::DCPS::RepoId& ignoreId);

  virtual void ignore_topic(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& myParticipantId,
    const OpenDDS::DCPS::RepoId& ignoreId);

  virtual void ignore_subscription(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& myParticipantId,
    const OpenDDS::DCPS::RepoId& ignoreId);

  virtual void ignore_publication(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& myParticipantId,
    const OpenDDS::DCPS::RepoId& ignoreId);

  virtual CORBA::Boolean update_publication_qos(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& dwId,
    const DDS::DataWriterQos & qos,
    const DDS::PublisherQos & publisherQos);

  /// Entry for federation updates of DataWriterQos values.
  void update_publication_qos(
    DDS::DomainId_t            domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& dwId,
    const DDS::DataWriterQos&  qos);

  /// Entry for federation updates of PublisherQos values.
  void update_publication_qos(
    DDS::DomainId_t            domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& dwId,
    const DDS::PublisherQos&   qos);

  virtual CORBA::Boolean update_subscription_qos(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& drId,
    const DDS::DataReaderQos & qos,
    const DDS::SubscriberQos & subscriberQos);

  /// Entry for federation updates of DataReaderQos values.
  void update_subscription_qos(
    DDS::DomainId_t            domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& drId,
    const DDS::DataReaderQos&  qos);

  /// Entry for federation updates of SubscriberQos values.
  void update_subscription_qos(
    DDS::DomainId_t            domainId,
    const OpenDDS::DCPS::RepoId& partId,
    const OpenDDS::DCPS::RepoId& drId,
    const DDS::SubscriberQos&  qos);

  virtual ::CORBA::Boolean update_subscription_params(
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const OpenDDS::DCPS::RepoId& subscriptionId,
    const DDS::StringSeq& params);

  virtual CORBA::Boolean update_topic_qos(
    const OpenDDS::DCPS::RepoId& topicId,
    DDS::DomainId_t domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    const DDS::TopicQos & qos);

  virtual CORBA::Boolean update_domain_participant_qos(
    DDS::DomainId_t domain,
    const OpenDDS::DCPS::RepoId& participantId,
    const DDS::DomainParticipantQos & qos);

  /// Cause the entire repository to exit.
  virtual void shutdown();

  /// Dump the Repos state to string.
  virtual char* dump_to_string();

  /**
   * @brief assert new ownership for a participant and its contained entities.
   *
   * @param domainId      the domain in which the participant resides.
   * @param participantId the participant to be owned.
   * @param sender        the repository sending the update data.
   * @param owner         the repository which is to make callbacks for
   *                      entities within the participant.
   * @return boolean indicating that ownership has been assigned.
   *
   * This establishes @c owner as the new owner of the participant.
   * Ownership consists of calling back to the reader and writer remote
   * interfaces when associations are established and removed from a
   * publication or subscription.  Owner may be the special value of
   * OWNER_NONE to indicate that the previous owner is no longer
   * available to make callbacks and the application has not indicated
   * which repository is to replace it in this capacity.
   *
   * The @c sender of the update is included so that the participant can
   * check that transitions to OWNER_NONE are only honored when initiated
   * by the current owner of the participant.
   *
   * A return value of @c false indicates that the ownership was
   * specified for a domain or participant which could not be found.
   */
  bool changeOwnership(
    DDS::DomainId_t              domainId,
    const OpenDDS::DCPS::RepoId& participantId,
    long                           sender,
    long                           owner);

  /// Initialize the transport for the Built-In Topics
  /// Returns 0 (zero) if succeeds
  int init_transport(int listen_address_given,
                     const char* listen_str);

  bool receive_image(const Update::UImage& image);

  /// Add an additional Updater interface.
  void add(Update::Updater* updater);

  /// Convert a domain Id into a reference to a DCPS_IR_Domain object.
  DCPS_IR_Domain* domain(DDS::DomainId_t domain);

  /// Expose a readable reference of the domain map.
  const DCPS_IR_Domain_Map& domains() const;

  /// Expose the ORB.
  CORBA::ORB_ptr orb();

  bool init_persistence();

  bool init_reassociation(const ACE_Time_Value& delay);

  bool init_dispatchChecking(const ACE_Time_Value& delay);

  /// Cleanup state for shutdown.
  void finalize();

private:
  DCPS_IR_Domain_Map domains_;
  CORBA::ORB_var orb_;
  CORBA::ORB_var dispatchingOrb_;

  const TAO_DDS_DCPSFederationId& federation_;
  RepoIdGenerator participantIdGenerator_;

  Update::Manager* um_;
  bool reincarnate_;

  /// Interface to effect shutdown of the process.
  ShutdownInterface* shutdown_;

  ACE_Recursive_Thread_Mutex lock_;

  long reassociate_timer_id_;
  long dispatch_check_timer_id_;
};

#endif /* DCPSINFO_I_H */


text:
"""
Definition of ListNode

class ListNode(object):

    def __init__(self, val, next=None):
        self.val = val
        self.next = next
"""
class Solution:
    """
    @param head: The first node of the linked list.
    @return: You should return the head of the reversed linked list.
                  Reverse it in-place.
    """
    def reverse(self, head):
        current = None
        pre = None
        if head.next == None or head == None:
            return head
        while head.next != None:
            current = head
            head = current.next
            current.next = pre
            pre = current
        head.next = pre
        return head


text:
<TITLE>The Container Adaptor priority queue</TITLE>
<LINK REL=StyleSheet HREF="../rw.css" TYPE="text/css" TITLE="Rogue Wave Standard Stylesheet">

Rogue Wave C++ Standard Library User's Guide

Chapter 11: The Container Adaptor priority queue

11.1 The priority queue Data Abstraction

11.1.1 Include Files

11.2 The priority queue Operations

11.2.1 Declaration and Initialization of priority queue

11.3 Example Program: Event-Driven Simulation

11.3.1 Example Program: An Ice Cream Store Simulation


text:
using System.Activities;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using Microsoft.Xrm.Sdk.Workflow;

namespace UltimateWorkflowToolkit.CoreOperations.Email
{
    public class SendEmailToUnresolvedRecipient : SendEmail
    {
        #region Inputs/Outputs

        [Input("Recipient Email")]
        [RequiredArgument]
        public InArgument<string> RecipientEmail { get; set; }

        [Input("Send Email")]
        [RequiredArgument]
        [Default("True")]
        public InArgument<bool> SendAfterOperation { get; set; }

        #endregion Inputs/Outputs

        protected override void ExecuteWorkflowLogic()
        {
            var emailId = Email.Get(Context.ExecutionContext).Id;

            var email = Context.UserService.Retrieve("email", emailId, new ColumnSet("to"));

            var to = email.Contains("to") ? email.GetAttributeValue<EntityCollection>("to") : new EntityCollection();
            var newRecipient = new Entity("activityparty")
            {
                ["addressused"] = RecipientEmail.Get(Context.ExecutionContext)
            };
            to.Entities.Add(newRecipient);

            email["to"] = to;

            Context.UserService.Update(email);

            if (SendAfterOperation.Get(Context.ExecutionContext))
                base.ExecuteWorkflowLogic();
        }
    }
}


text: A brief presentation on preprocessors. Uses reveal.js


text:
<!DOCTYPE html>

		<meta charset="utf-8">
		<title>*Chess*Chatting*</title>
		<meta charset="utf-8"/>
		<meta http-equiv="X-UA-Compatible" content="IE=edge"/>
		<meta http-equiv="Content-Language" content="en"/>
		<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
		<meta name="description" content="*Chess*Chatting*"/>
		<link rel="icon" href="./images/mychatchess.png" type="image/png" sizes="48x48"/>
		<meta property="og:title" content="*Chess*Chatting*"/>
		<meta content="https://github.com/gittyRavi/NNChess/blob/master/images/chess-piece-pawn.png" property="og:image" />
		<meta property="og:description" content="A chess application game with chat implementation from socket.io"/>
		<meta name="keywords" content="web,design,html,css,html5,development,chess,chat,chatting,chessy,pawn,rook,bishop,knight,queen,king,black,white,pieces,game,a.i.,artificial,intelligence,ravi,saxena,board,gui"/>
		<meta name="author" content="Ravi Saxena"/>

		<link rel="stylesheet" href="./assets/css/bootstrap.css">

		<link href="styles.css" rel="stylesheet" type="text/css">

*Chess*Chatting*

			<input type="text" id="fenIn" style="border: solid 2px blue;border-radius:20px;color: pink;background-color: rgba(100,155,100,0.9);text-indent:4px;font-weight:bold;"/>
			<button type="button" id="SetFen" style="border: solid 2px blue;border-radius:20px;color: yellow;background-color: rgba(10,55,10,0.5);font-weight:bold;">Set Position</button>

&nbsp Statistics &nbsp

&nbsp Thinking Time:

			&nbsp
			<select id="ThinkTimeChoice" style="border:solid 2px black;border-radius:30px;font-weight:bold;">
			  <option value="1">1s</option>
			  <option value="2">2s</option>
			  <option value="4">4s</option>
			  <option value="6">6s</option>
			  <option value="8">8s</option>
			  <option value="10">10s</option>
			</select>

			&nbsp &nbsp BestMove:

			&nbsp &nbsp Depth:

			&nbsp &nbsp Score:

			&nbsp &nbsp Nodes:

			&nbsp &nbsp Ordering:

			&nbsp &nbsp Time:

			&nbsp <button type="button" id="SearchButton" style="border: solid 2px yellow;border-radius:20px;color: yellow;background-color: rgba(255,0,0,0.5);font-weight:bold;"> Move Now</button>

			&nbsp <button type="button" id="NewGameButton" style="border: solid 2px yellow;border-radius:20px;color: yellow;background-color: rgba(255,0,0,0.5);font-weight:bold;"> New Game</button>

			&nbsp <button type="button" id="FlipButton" style="border: solid 2px yellow;border-radius:20px;color: yellow;background-color: rgba(255,0,0,0.5);font-weight:bold;"> Flip Board</button>

			&nbsp <button type="button" id="TakeButton" style="border: solid 2px yellow;border-radius:20px;color: yellow;background-color: rgba(255,0,0,0.5);font-weight:bold;"> Take Back</button>

			&nbsp


text:
Good Design ...

... Is Innovative

... Makes a Product Useful

... Is Aesthetic

... Makes A Product Understandable

... Is Unobtrusive

... Is Honest

... Is Long-lasting

... Is Thorough Down to the Last Detail

... Is Environmentally Friendly

... Is as Little Design as Possible

Source: San Francisco Museum of Modern Art - The design ethos of Dieter Rams

Image: 606 Universal Shelving System, 1960, by Dieter Rams


text:
..
..
.. 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.
..

.. _to-api-v3-federations-id-deliveryservices-id:

************************************************
``federations/{{ID}}/deliveryservices/{{dsID}}``
************************************************

``DELETE``
==========
Removes a :term:`Delivery Service` from a federation. A :term:`Delivery Service` cannot be removed from a federation if it is the only :term:`Delivery Service` assigned to said federation

:Auth. Required: Yes
:Roles Required: "admin"
:Response Type:  ``undefined``

Request Structure
-----------------
.. table:: Request Path Parameters

	+------+----------------------------------------------------------------------------------------------------------------------------------+
	| Name | Description                                                                                |
	+======+==================================================================================================================================+
	|  ID  | The integral, unique identifier of the federation from which the :term:`Delivery Service` identified by ``dsID`` will be removed |
	+------+----------------------------------------------------------------------------------------------------------------------------------+
	| dsID | The integral, unique identifier of the :term:`Delivery Service` which will be removed from the federation identified by ``ID``   |
	+------+----------------------------------------------------------------------------------------------------------------------------------+

.. code-block:: http
	:caption: Request Example

	DELETE /api/3.0/federations/1/deliveryservices/1 HTTP/1.1
	Host: trafficops.infra.ciab.test
	User-Agent: curl/7.62.0
	Accept: */*
	Cookie: mojolicious=...

Response Structure
------------------
.. code-block:: http
	:caption: Response Example

	HTTP/1.1 200 OK
	access-control-allow-credentials: true
	access-control-allow-headers: Origin, X-Requested-With, Content-Type, Accept
	access-control-allow-methods: POST,GET,OPTIONS,PUT,DELETE
	access-control-allow-origin: *
	cache-control: no-cache, no-store, max-age=0, must-revalidate
	content-type: application/json
	date: Wed, 05 Dec 2018 01:06:51 GMT
	X-Server-Name: traffic_ops_golang/
	set-cookie: mojolicious=...; expires=Wed, 05 Dec 2018 05:06:51 GMT; path=/; HttpOnly
	vary: Accept-Encoding
	whole-content-sha512: NqAZuZYlF1UWOaazbj/j4gWX7ye0kGGakRRFEkK6ShxqXvCxE0dCTyu75qiLPN2wSgr3FGQnp2Sq345sE7In9g==
	content-length: 98

	{ "alerts": [
		{
			"level": "success",
			"text": "federation deliveryservice was deleted."
		}
	]}


text:
package org.kuali.rice.ksb.impl.registry;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.kuali.rice.core.api.criteria.GenericQueryResults;
import org.kuali.rice.core.api.criteria.QueryByCriteria;
import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
import org.kuali.rice.krad.data.DataObjectService;
import org.kuali.rice.ksb.api.registry.ServiceInfo;
import org.kuali.rice.ksb.api.registry.ServiceRegistry;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;

/**
 * A unit test for {@link ServiceRegistryImpl}
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 */
@RunWith(MockitoJUnitRunner.class)
public class ServiceRegistryImplTest {

    @Mock private DataObjectService dataObjectService;

    @InjectMocks private ServiceRegistryImpl serviceRegistryImpl = new ServiceRegistryImpl();
    private ServiceRegistry serviceRegistry = serviceRegistryImpl;

    public ServiceRegistry getServiceRegistry() {
        return serviceRegistry;
    }

    public void setServiceRegistry(ServiceRegistry serviceRegistry) {
        this.serviceRegistry = serviceRegistry;
    }

    @Test(expected = RiceIllegalArgumentException.class)
    public void testGetAllServicesForInstance_Null() {
        serviceRegistry.getAllServicesForInstance(null);
    }

    @Test(expected = RiceIllegalArgumentException.class)
    public void testGetAllServicesForInstance_Empty() {
        serviceRegistry.getAllServicesForInstance("");
    }

    @Test(expected = RiceIllegalArgumentException.class)
    public void testGetAllServicesForInstance_Blank() {
        serviceRegistry.getAllServicesForInstance(" ");
    }

    @Test
    public void testGetAllServicesForInstance() {
        GenericQueryResults.Builder<ServiceInfoBo> resultBuilder = GenericQueryResults.Builder.<ServiceInfoBo>create();
        for (int i = 0; i < 5; i++) {
            resultBuilder.getResults().add(createServiceInfo("service" + i));
        }
        when(dataObjectService.findMatching(eq(ServiceInfoBo.class), any(QueryByCriteria.class))).thenReturn(resultBuilder.build());

        List<ServiceInfo> serviceInfos = serviceRegistry.getAllServicesForInstance("MyInstance");
        assertEquals(5, serviceInfos.size());
    }

    private static int ID_VALUE = 0;

    private String nextId() {
        ID_VALUE++;
        return ID_VALUE + "";
    }

    private ServiceInfoBo createServiceInfo(String serviceName) {
        ServiceInfoBo serviceInfo = new ServiceInfoBo();
        serviceInfo.setServiceId(nextId());
        serviceInfo.setServiceName(serviceName);
        serviceInfo.setEndpointUrl("localhost");
        serviceInfo.setInstanceId("MyInstance");
        serviceInfo.setApplicationId(nextId());
        serviceInfo.setServerIpAddress("127.0.0.1");
        serviceInfo.setType("type");
        serviceInfo.setServiceVersion("1.0");
        serviceInfo.setStatusCode("A");
        serviceInfo.setServiceDescriptorId(nextId());
        serviceInfo.setChecksum("abcdefg");
        return serviceInfo;
    }

}


text:
namespace nevil
{
  class json_logger
  {
  public:
    inline json_logger() {
      _output_file = new std::ofstream();
    };

    inline void start_new_file(const std::string &path, const std::string &file_name)
    {
      if (_output_file->is_open())
          _output_file->close();

      std::string file_path = os::append_path(path, file_name);
      _output_file->open(file_path.c_str(), std::ofstream::out);

      if (!(*_output_file))
      {
        std::cerr << "Failed to open the file \"" << file_path << "\"\nAborting now..." << std::endl;
        std::abort();
      }
    }

    inline void flush()
    {
      _output_file->flush();
    }

    inline void close_file()
    {
      _output_file->close();
    }

    inline void write(const Json::Value &root)
    {
      Json::StyledStreamWriter writer;
      writer.write(*_output_file, root);
    }

  protected:
      std::ofstream *_output_file;
  };
}

#endif // NEVIL_UTIL_JSON_LOGGER_HPP_


text:
package com.google.gwt.site.webapp.server.resources;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.FetchOptions;
import com.google.appengine.api.datastore.PreparedQuery;
import com.google.appengine.api.datastore.Query;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HashServlet extends HttpServlet {

  private static final long serialVersionUID = -8648249883829261848L;

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
      IOException {

    int count;
    try {
      count = Integer.parseInt(req.getParameter("count"));
    } catch (NumberFormatException e) {
      throw new ServletException(e);
    }

    if (count < 0) {
      throw new ServletException("invalid value count " + count);
    }

    JSONObject root = new JSONObject();

    DatastoreService ds = DatastoreServiceFactory.getDatastoreService();

    PreparedQuery pq = ds.prepare(new Query("DocHash"));

    List<Entity> asList = pq.asList(FetchOptions.Builder.withOffset(count).limit(1000));
    JSONArray array = new JSONArray();

    try {
      root.put("hashes", array);
      for (Entity entity : asList) {
        count++;
        String key = entity.getKey().getName();
        String hash = (String) entity.getProperty("hash");

        JSONObject docHash = new JSONObject();
        docHash.put("key", key);
        docHash.put("hash", hash);
        array.put(docHash);
      }

      resp.getWriter().write(root.toString());
    } catch (JSONException e) {
      throw new ServletException(e);
    }
  }
}


text:
---
title: Plugin Tutorial
taxonomy:
    category: docs
---

Plugins are usually developed because there is a task that can not be completed with Grav's core functionality.

In this tutorial, we will create a plugin that helps Grav to deliver a random page to the user.  You have probably seen similar functionality on blog sites as a way to provide a random blog-post when you click a button.

This feature is not possible **out-of-the-box**, but is **easily** provided via a plugin.  As is the case with a great many aspects of Grav, there is no _one-way_ to do this. Instead, you have many options.  We will cover just one approach...

## Random Plugin Overview

For our plugin we will take the following approach:

1. Activate the plugin if a URI matches our configured 'trigger route'. (e.g. `/random`)

2. Create a filter so that only configured taxonomies are in the pool of random pages.  (e.g. `category: blog`)

3. Find a random page from our filtered pool, and tell Grav to use it for the page content.

OK! This sounds simple enough, right? So, let us get cracking!

### Step 1 - Base plugin setup

Before we can start writing our actual plugin logic, we need to create the base setup for the plugin.

1. Follow the [Installation instruction](../../basics/installation) and ensure you have Grav properly installed.

2. Create a folder called `random` within the `user/plugins` folder of your Grav site to provide the basis of our new plugin.

3. In your new `user/plugins/random` folder you just created, we will create two files, one for the plugin code, and one for the default configuration:

	```
	random.php
	random.yaml
	```

### Step 2 - Plugin configuration

As we described in the **Plugin Overview**, we need to have a few configuration options for our plugin, so the `random.yaml` file should look something like this:

```
enabled: true
route: /random
filters:
    category: blog
```

This allows us to have multiple filters if we wish, but for now, we just want all content with the taxonomy `category: blog` to be eligible for the random selection.

>>>> The Grav default install has taxonomy defined for `category` and `tag` by default.  This configuration can be modified in your `user/config/site.yaml` file.

Of course, as with all other configurations in Grav, it is advised not to touch this default configuration for day-to-day control. Rather, you should create an override in a file called `/user/config/plugins/random.yaml` to house any custom settings.  This plugin-provided `random.yaml` is really intended to set some sensible defaults for your plugin.

### Step 3 - Base plugin structure

The base plugin class structure will need to look something like this:

```
<?php
namespace Grav\Plugin;

use Grav\Common\Page\Collection;
use Grav\Common\Plugin;
use Grav\Common\Uri;
use Grav\Common\Taxonomy;

class RandomPlugin extends Plugin
{

}
```

We have added a bunch of `use` statements because we are going to use these classes in our plugin, and it saves space and makes the code more readable if we don't have to put the full namespace for each class in-line.

The two key parts of this class structure are:

1. Plugins need to have `namespace Grav\Plugin` at the top of of the PHP file.
2. Plugins should be named in **titlecase** based on the name of the plugin with the string `Plugin` appended to the end, and should extend `Plugin`.

### Step 4 - Subscribed events

Grav uses a sophisticated event system, and to ensure optimal performance, all plugins are inspected by Grav to determine which events the plugin is subscribed to.

```
public static function getSubscribedEvents() {
    return [
        'onPluginsInitialized' => ['onPluginsInitialized', 0],
    ];
}
```

In this plugin we are going to tell Grav we're subscribing to the `onPluginsInitialized` event.  This way we can use that event (which is the first event available to plugins) to determine if we should subscribe to other events.

### Step 5 - Determine if the plugin should run

The next step is to add a method to our `RandomPlugin` class to handle the `onPluginsInitialized` event so it only activates when a user tries to go to the route we have configured in our `random.yaml` file:

```
public function onPluginsInitialized()
{
    /** @var Uri $uri */
    $uri = $this->grav['uri'];
    $route = $this->config->get('plugins.random.route');

    if ($route && $route == $uri->path()) {
        $this->enable([
            'onPageInitialized' => ['onPageInitialized', 0]
        ]);
    }
}
```

First, we get the **Uri object** from the **Dependency Injection Container**.  This contains all the information about the current URI, including the route information.

The **config object** is already part of the base **Plugin**, so we can simply use it to get the configuration value for our configured `route`.

Next, we compare the configured route to the current URI path. If they are equal, we instruct the dispatcher that our plugin will also listen to a new event: `onPageInitialized`.

By using this approach, we ensure we do not run through any extra code if we do not need to.  Practices like these will ensure your site runs as fast as possible.

### Step 6 - Display the random page

The last step of our plugin is to display the random page, and we can do that with the following method:

```
public function onPageInitialized()
{
    $taxonomy_map = $this->grav['taxonomy'];

    $filters = (array) $this->config->get('plugins.random.filters');
    $operator = $this->config->get('plugins.random.filter_combinator', 'and');

    if (count($filters)) {
        $collection = new Collection();
        $collection->append($taxonomy_map->findTaxonomy($filters, $operator)->toArray());
        if (count($collection)) {
            unset($this->grav['page']);
            $this->grav['page'] = $collection->random()->current();
        }
    }
}
```

This method is a bit more complicated, so we'll go over what's going on:

1. First, we get the **Taxonomy object** from the **Grav DI Container** and assign it to a variable `$taxonomy_map`.

2. Then we retrieve the array of filters from our plugin configuration.  In our configuration this is an array with 1 item: ['category' => 'blog'].

3. Check to ensure we have filters, then create a new `Collection` in the `$collection` variable to store our pages.

4. Append all pages that match the filter to our `$collection` variable.

5. Unset the current `page` object that Grav knows about.

6. Set the current `page` to a random item in the collection.

### Step 7 - Final plugin class

And that is all there is to it! The plugin is now complete.  Your complete plugin class should look something like this:

```
<?php
namespace Grav\Plugin;

use Grav\Common\Page\Collection;
use Grav\Common\Plugin;
use Grav\Common\Uri;
use Grav\Common\Taxonomy;

class RandomPlugin extends Plugin
{
    public static function getSubscribedEvents() {
        return [
            'onPluginsInitialized' => ['onPluginsInitialized', 0],
        ];
    }

    public function onPluginsInitialized()
    {
        $uri = $this->grav['uri'];
        $route = $this->config->get('plugins.random.route');

        if ($route && $route == $uri->path()) {
            $this->enable([
                'onPageInitialized' => ['onPageInitialized', 0]
            ]);
        }
    }

    public function onPageInitialized()
    {
        $taxonomy_map = $this->grav['taxonomy'];

        $filters = (array) $this->config->get('plugins.random.filters');
        $operator = $this->config->get('plugins.random.filter_combinator', 'and');

        if (count($filters)) {
            $collection = new Collection();
            $collection->append($taxonomy_map->findTaxonomy($filters, $operator)->toArray());
            if (count($collection)) {
                unset($this->grav['page']);
                $this->grav['page'] = $collection->random()->current();
            }
        }
    }
}
```

If you followed along, you should have a fully functional **Random** plugin enabled for your site.  Just point your browser to the `http://yoursite.com/random`, and you should see a random page.  You can also download this plugin directly from the [Plugins Download](http://getgrav.org/downloads/plugins) section of the [getgrav.org](http://getgrav.org/downloads/plugins) site.

### Merging Plugin and Page Configuration

One popular technique that is used in a variety of plugins is the concept of merging the plugin configuration (either default or overridden user config) with page-level configuration.  This means you can set **site-wide** configuration, and then have a specific configuration for a given page as needed.  This is provides a lot of power and flexibility for your plugin.

In recent versions of Grav, a helper method was added to perform this functionality automatically rather than you having to code that logic yourself.  The **SmartyPants** plugin provides a good example of this functionality in action:

```
public function onPageContentProcessed(Event $event)
{
    $page = $event['page'];
    $config = $this->mergeConfig($page);

    if ($config->get('process_content')) {
        $page->setRawContent(\Michelf\SmartyPants::defaultTransform(
            $page->getRawContent(),
            $config->get('options')
        ));
    }
}
```


text:
<!DOCTYPE html>

<meta charset="utf-8">

						<form class="form-horizontal m-t" id="signupForm">

								活动发起人:

									<input id="initiator" name="initiator" class="form-control" type="text">

								活动开始时间:

									<input id="fromTime" name="fromTime" class="form-control" type="text">

								活动结束时间:

									<input id="endTime" name="endTime" class="form-control" type="text">

								地址:

									<input id="address" name="address" class="form-control" type="text">

								预算金额:

									<input id="budgetAmount" name="budgetAmount" class="form-control" type="text">

								参与人:

									<input id="activeUsers" name="activeUsers" class="form-control" type="text">

								描述:

									<input id="description" name="description" class="form-control" type="text">

								创建时间:

									<input id="createTime" name="createTime" class="form-control" type="text">

								更新时间:

									<input id="updateTime" name="updateTime" class="form-control" type="text">

								创建人:

									<input id="createUser" name="createUser" class="form-control" type="text">

								更新人:

									<input id="updateUser" name="updateUser" class="form-control" type="text">

									<button type="submit" class="btn btn-primary">提交</button>

						</form>


text:
import zgui.guilocal as local
import pygame

QUIT = pygame.QUIT
MOUSEBUTTONDOWN = pygame.MOUSEBUTTONDOWN
MOUSEBUTTONUP = pygame.MOUSEBUTTONUP
KEYDOWN = pygame.KEYDOWN
KEYUP = pygame.KEYUP


text:
@implementation BZObjectStoreOnDisk

+ (NSString*)databasePath:(NSString*)path
{
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
    NSString *dir = [paths objectAtIndex:0];
    path = [dir stringByAppendingPathComponent:path];
    return path;
}

+ (NSString*)ignorePrefixName
{
    return @"BZ";
}

+ (NSString*)ignoreSuffixName
{
    return @"Model";
}

- (void)transactionDidBegin:(FMDatabase *)db
{
}

- (void)transactionDidEnd:(FMDatabase *)db
{
}

@end


text:
define({
  "_widgetLabel": "Conştientizare situaţie",
  "locate_incident": "Localizare incident",
  "clear_incidents": "Golire incidente",
  "reverse_geocoded_address": "Cea mai apropiată adresă",
  "reverse_geocoded_error": "Indisponibil",
  "miles": "Mile",
  "kilometers": "Kilometri",
  "feet": "Ft",
  "meters": "Metri",
  "yards": "Iarzi",
  "nauticalMiles": "Mile marine",
  "now": "ACUM",
  "wind": "VÂNT",
  "SUN": "DUM",
  "MON": "LUN",
  "TUE": "MAR",
  "WED": "MIE",
  "THU": "JOI",
  "FRI": "VIN",
  "SAT": "SÂM",
  "defaultTabMsg": "Vă rugăm să definiţi o zonă de incident.",
  "actionLabel": "Setare ca incident",
  "drawPoint": "Trasare punct",
  "drawLine": "Trasare linie",
  "drawPolygon": "Trasare poligon",
  "saveIncident": "Salvare incident",
  "clearIncident": "Golire incident",
  "useMapExtent": "Utilizare extindere curentă a hărţii",
  "noFeaturesFound": "Nu a fost găsit niciun obiect spaţial.",
  "downloadCSV": "DESCĂRCARE CSV",
  "editComplete": "Obiect spaţial salvat cu succes.",
  "updateComplete": "Obiect spaţial actualizat cu succes.",
  "deleteComplete": "Obiect spaţial şters cu succes.",
  "sum": "SUMĂ",
  "min": "MIN.",
  "max": "MAX",
  "avg": "MED.",
  "count": "NUMĂR",
  "area": "SUPRAFAŢĂ",
  "length": "LUNGIME",
  "notPolySave": "Specificaţi o distanţă de buffer înainte de a salva.",
  "update_btn": "Gata",
  "delete_btn": "Ştergere",
  "get_directions": "Obţinere instrucţiuni",
  "incident": "Incident",
  "weather": "Vreme",
  "poweredBy": "Sprijinit de"
});


text:
<?php

namespace FSi\Component\DataGrid\Tests\Fixtures;

class Entity
{
    private $name;

    private $author;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setAuthor($author)
    {
        $this->author = $author;
        return $this;
    }

    public function getAuthor()
    {
        return $this->author;
    }
}