कोटलिन में स्थिरांक - उन्हें बनाने के लिए एक अनुशंसित तरीका क्या है?

Question

कोटलिन में स्थिरांक बनाने की सिफारिश कैसे की जाती है? और नामकरण सम्मेलन क्या है? मैंने दस्तावेज में नहीं पाया है।

companion object {
    //1
    val MY_CONST = "something"

    //2
    const val MY_CONST = "something"

    //3
    val myConst = "something"
}

या ...?

Comments

यदि आप public static finalजावा में किसी फ़ील्ड के लिए कुछ चाहते हैं , तो const valअपने साथी ऑब्जेक्ट में उपयोग करें। यदि आप एक private static finalफील्ड और पब्लिक गेट्टर चाहते हैं, तो valअपने साथी ऑब्जेक्ट में उपयोग करें।

— माइकल

यहाँ वह ब्लॉगपोस्ट है जो कोटलिन

— Micer

चेकआउट इस लेख । यह विभिन्न तरीकों का एक अच्छा अवलोकन देता है जिसमें आप संबंधित प्रदर्शन व्यापार-नापसंद के साथ अपने स्थिरांक को स्टोर कर सकते हैं।

— fiedrillsergeant

एक नज़र में, वैल बनाम कॉन्स्ट

— अनूप एम

Answer 1

कोटलिन में, यदि आप स्थानीय स्थिरांक बनाना चाहते हैं जिसे कक्षा में उपयोग किया जाना है तो आप इसे नीचे की तरह बना सकते हैं

val MY_CONSTANT = "Constants"

और अगर आप जावा में सार्वजनिक स्थैतिक फाइनल जैसे कोटलिन में एक सार्वजनिक स्थिरांक बनाना चाहते हैं , तो आप इसे फॉलो के रूप में बना सकते हैं।

companion object{

     const val MY_CONSTANT = "Constants"

}

Comments

मैं इसे एक अलग फ़ाइल में कैसे उपयोग करूँगा जैसे कि एक नई फ़ाइल जिसका नाम है Constants.ktया कैसे है?

— नवेद अब्बास

मैं स्थिरांक के लिए एक फ़ाइल का उपयोग करता हूं। मेरे सभी स्थिरांक को वहां रखो।

— गंदी_विलास

आपको नहीं companion objectलगता कि मुझे लगता है कि @piotrpo उत्तर को स्वीकार किया जाना चाहिए

— Chiara

@ चियारा साथी वस्तु (और इसका संलग्न वर्ग) शीर्ष स्तर की घोषणाओं के विपरीत, एक नामस्थान के रूप में कार्य करता है। मुझे लगता है कि दोनों जवाब स्थिति के आधार पर समझ में आ सकते हैं।

— जिंगक्स

@jingx हां, आपके पास एक नामस्थान जोड़ने के लिए एक बिंदु है जिसमें आपको इसकी आवश्यकता है। : +1:

— चियारा

Answer 2

साथी वस्तुओं के उपयोग से बचें। हुड के पीछे, फ़ील्ड के लिए गेट्टर और सेटर इंस्टेंस विधियाँ सुलभ होने के लिए बनाई गई हैं। इंस्टेंस विधियों को कॉल करने की तुलना में इंस्टेंस विधियों को कॉल करना तकनीकी रूप से अधिक महंगा है।

public class DbConstants {
    companion object {
        val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        val TABLE_USER_ATTRIBUTE_DATA = "data"
    }

इसके बजाय स्थिरांक में परिभाषित करें object।

अनुशंसित अभ्यास :

object DbConstants {
        const val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        const val TABLE_USER_ATTRIBUTE_DATA = "data"
}

और इस तरह से उन्हें विश्व स्तर पर एक्सेस करें: DbConstants.TABLE_USER_ATTRIBUTE_EMPID

Comments

क्या एक साथी वस्तु का एक विशेष मामला नहीं है? const valएक साथी वस्तु const valमें एक साधारण वस्तु की तुलना में कोई भी भिन्न कैसे हो सकता है (यानी आपके उदाहरणों के बीच एकमात्र अंतर यह प्रतीत होता है कि आप constसाथी वस्तु मामले में छोड़ दिए गए हैं - यदि आप जोड़ते हैं const, तो उदाहरणों का प्रदर्शन समान होना चाहिए)

— एरविन बोलविएट 23

@ErwinBolwidt मुझे लगता है कि @ सुदेश की बात यह है कि किसी को वर्ग-रैपिंग-साथी-ऑब्जेक्ट डिज़ाइन का उपयोग नहीं करना चाहिए जब संरचना का एकमात्र उद्देश्य कुछ निरंतर मूल्यों के लिए एक नाम स्थान प्रदान करना है। लेकिन अगर आपकी संरचना को तत्काल बनाने की आवश्यकता है और const valएस के एक जोड़े को संलग्न करना भी companion objectसही है।

— अरी लैकेन्स्की

@ErwinBolwidt: सुडेश सही है, साथी वस्तुओं के लिए उत्पन्न बायटेकोड में हुड के नीचे गेटर्स के साथ अतिरिक्त ऑब्जेक्ट निर्माण शामिल है। Decompiled kotlin उदाहरण के साथ एक अच्छा विवरण के लिए देख blog.egorand.me/where-do-i-put-my-constants-in-kotlin

— डोमिनिक

धन्यवाद @dominik, यह एक बहुत ही विस्तृत लेख है, मैं इसे उन सभी के लिए सुझाता हूं जो इसे गहराई से समझना चाहते हैं, ऐसे कई मामले हैं जहां कोटलिन उप-प्रॉपर्टी बायोटेक का उत्पादन करता है, जेटब्रेन्स ने कई ऐसे प्रदर्शन संबंधी बगों को हल किया है ... चर्चा पर नजर रखें .kotlinlang.org , आपको ऐसे कई अंतर्निहित पहलुओं के बारे में सूचित किया जाएगा।

— सुदेश

मैंने आज आपके जवाब से बहुत कुछ सीखा है @sudesh धन्यवाद!

— राखी धवले

Answer 3

सबसे पहले , स्थिरांक के लिए कोटलिन में नामकरण सम्मेलन जावा की तुलना में समान है (जैसे: MY_CONST_IN_UPPERCASE)।

मुझे इसे कैसे बनाना चाहिए?

1. शीर्ष स्तर के मूल्य के रूप में (अनुशंसित)

आपको बस अपनी कक्षा की घोषणा के बाहर अपना कॉन्स्टेबल रखना होगा ।

दो संभावनाएँ : अपनी कक्षा की फ़ाइल में अपने कास्ट की घोषणा करें (आपके कास्ट का आपकी कक्षा के साथ एक स्पष्ट संबंध है)

private const val CONST_USED_BY_MY_CLASS = 1

class MyClass { 
    // I can use my const in my class body 
}

एक समर्पित constants.kt फ़ाइल बनाएँ जहाँ उन वैश्विक कॉन्स्ट को स्टोर करें (यहाँ आप अपने प्रोजेक्ट में व्यापक रूप से अपने कॉन्स्ट का उपयोग करना चाहते हैं):

package com.project.constants
const val URL_PATH = "https:/"

फिर आपको बस इसे आयात करना होगा जहाँ आपको इसकी आवश्यकता है:

import com.project.constants

MyClass {
    private fun foo() {
        val url = URL_PATH
        System.out.print(url) // https://
    }
}

2. इसे एक साथी वस्तु (या एक वस्तु घोषणा) में घोषित करें

यह बहुत कम क्लीनर है क्योंकि हुड के तहत, जब बायटेकोड उत्पन्न होता है, तो एक बेकार वस्तु बनाई जाती है:

MyClass {
    companion object {
        private const val URL_PATH = "https://"
        const val PUBLIC_URL_PATH = "https://public" // Accessible in other project files via MyClass.PUBLIC_URL_PATH
    }
}

इससे भी बदतर अगर आप इसे एक कास्ट के बजाय एक वैल के रूप में घोषित करते हैं (संकलक एक बेकार वस्तु + एक बेकार फ़ंक्शन उत्पन्न करेगा):

MyClass {
    companion object {
        val URL_PATH = "https://"
    }
}

ध्यान दें :

कोटलिन में, कास्ट केवल आदिम प्रकार पकड़ सकता है। यदि आप इसके लिए कोई फ़ंक्शन पास करना चाहते हैं, तो आपको @JvmField एनोटेशन जोड़ना होगा। संकलन के समय, यह सार्वजनिक स्थैतिक अंतिम चर के रूप में परिवर्तित हो जाएगा। लेकिन यह एक आदिम प्रकार की तुलना में धीमी है। इससे बचने की कोशिश करें।

@JvmField val foo = Foo()

Comments

यह स्वीकृत उत्तर होना चाहिए। वैसे भी एक मामले में: सार्वजनिक स्थिर अंतिम पैटर्न REGEX_NOTEMPTY = Pattern.compile ("। +")) ????

— Xan

Answer 4

संकलन समय पर ज्ञात मूल्य (और मेरी राय में) को निरंतर के रूप में चिह्नित किया जाना चाहिए।

नामकरण परंपराओं को जावा वाले का पालन करना चाहिए और जावा कोड से उपयोग किए जाने पर इसे ठीक से दिखाई देना चाहिए (यह किसी भी तरह से साथी वस्तुओं के साथ प्राप्त करना कठिन है, लेकिन वैसे भी)।

उचित निरंतर घोषणाएँ हैं:

const val MY_CONST = "something"
const val MY_INT = 1

Comments

Naming conventions should follow Java ones- क्यों?

— जोदिमोरो

कोटलिन आमतौर पर जावा सम्मेलनों का पालन डिफ़ॉल्ट रूप से करता है, यदि अन्यथा निर्दिष्ट नहीं है, तो इंटरॉप को सुचारू बनाने के लिए।

— zsmb13

दस्तावेज में इस तरह निर्दिष्ट किया गया है @Jodimoro kotlinlang.org/docs/reference/coding-conventions.html

— नील

@ नहीं, यह नहीं है।

— जोदिमोरो

उस लिंक में मैंने पोस्ट किया था वे कहते हैंIf in doubt, default to the Java Coding Conventions

— नील

Answer 5

कोटलिन में स्थिरांक घोषित करने के लिए आपको एक वर्ग, एक वस्तु या एक साथी वस्तु की आवश्यकता नहीं है। आप बस सभी स्थिरांक रखने वाली फ़ाइल की घोषणा कर सकते हैं (उदाहरण के लिए Constants.kt या आप उन्हें किसी भी मौजूदा कोटलिन फ़ाइल के अंदर रख सकते हैं) और सीधे फ़ाइल के अंदर स्थिरांक घोषित करें। संकलन समय पर ज्ञात स्थिरांक के साथ चिह्नित किया जाना चाहिए const।

तो, इस मामले में, यह होना चाहिए:

const val MY_CONST = "something"

और फिर आप का उपयोग करके निरंतर आयात कर सकते हैं:

import package_name.MY_CONST

आप इस लिंक को देख सकते हैं

Comments

कॉन्स्टेंट को उस कक्षा में होना चाहिए जो वे संबंधित हैं। यदि आप एक 'कॉन्स्टेंट' वर्ग बनाते हैं, तो आप अंत में, इसके भीतर सैकड़ों स्थिरांक बन जाएंगे। पीई: MAX_WIDTH, MAX_HEIGHT स्क्रीन वर्ग में होनी चाहिए ताकि आप इसे तार्किक रूप से एक्सेस कर सकें: Screen.MAX_WIDTH और आपको Constants.SCREEN_MAX_WIDTH डालने की आवश्यकता नहीं है जो 2 वर्षों में Constants.SCR_MAX_W और Constants.MAX_WIDTH के साथ दोहराई जाएगी क्योंकि NOBODY जब वे स्वत: पूर्ण करने के लिए Ctrl + स्थान को धक्का देते हैं, तो सैंकड़ों / पाइरेट्स रेखाएँ नीचे आ जाती हैं। गंभीरता से: यह मत करो।

— अप्राप्यता की

@inigoD यह सच है यदि आप एक ही स्थान पर या केवल बच्चों में निरंतर उपयोग करते हैं, लेकिन शायद ही कभी ऐसा हो। यदि आप स्थिरांक को अस्पष्ट कक्षा में रखते हैं, तो आप इसके बारे में भूल जाते हैं या अधिक संभावना है कि आप एक कोड आधार लेते हैं, आप उन्हें डुप्लिकेट कर सकते हैं। या यह स्पष्ट नहीं है कि उन्हें कहां रखा जाए। स्रोत या गंतव्य? आप कई निरंतर फ़ाइलें बना सकते हैं, जिन्हें ढूंढना आसान है। वरीयता कुंजियों के लिए एक, अनुरोध कुंजियों के लिए एक, व्यू

— कॉन्स्टेंट के

@ Herrbert74 मुझे खेद है लेकिन मुझे आपसे असहमत होना पड़ेगा। मैं इस बात पर सहमत हूं कि कभी-कभी यह पता लगाना कठिन हो सकता है कि कौन सी जगह है, लेकिन एक निरंतर स्थान हमेशा वह वर्ग होना चाहिए जो इससे संबंधित हो। और उन्हें बेतरतीब ढंग से संख्या फ़ाइलों में सहेजना सबसे अच्छा तरीका नहीं है यदि आप उन्हें बाद में पुनर्प्राप्त करना चाहते हैं ... तो आप तर्क देंगे कि वे बेतरतीब ढंग से संग्रहीत नहीं होंगे लेकिन संकुल में संबंधित हैं, लेकिन यह केवल एक बहाना है उन्हें उन वर्गों में न रखें जो वे संबंधित हैं, जो अंत में हैं, उनके स्थान पर ...

— inigoD

यदि कोई स्थिरांक वास्तव में वैश्विक है या उसके पास एक बड़ा स्कोप है ... जैसे कि सभी पैकेजों में उपयोग किए गए एनोटेशन के लिए मान, या एक हैडर का नाम, जिसे कई कंट्रोलर आदि द्वारा लिया जा रहा है, तो यह "स्थिरांक बनाने के लिए पूरी तरह से स्वीकार्य है। वर्ग "जो उचित रूप से स्कूप किया गया है। हालांकि, स्थिरांक जो केवल विशिष्ट संदर्भों में उपयोग किए जाते हैं, उन्हें उस संदर्भ में स्कोप किया जाना चाहिए, और संबंधित वर्ग में घोषित किया जाना चाहिए।

— नेफ्थिसेस76

@ Nephthys76 सिर्फ एक नोट के रूप में, "विशेष रूप से सभी पैकेजों में उपयोग किए जाने वाले एनोटेशन के लिए एक मूल्य " के लिए, विशेष रूप से, मैं कहूंगा कि निरंतर के लिए सबसे अच्छी जगह एनोटेशन वर्ग में है।

— slaw

Answer 6

यदि आप अपना const val valName = valValueनाम कक्षा के नाम से पहले रखते हैं, तो यह इस तरह से बना देगा

public static final YourClass.Ktइसका public static finalमूल्य होगा।

कोटलिन :

const val MY_CONST0 = 0
const val MY_CONST1 = 1
data class MyClass(var some: String)

जावा विघटित:

public final class MyClassKt {
    public static final int MY_CONST0 = 0;
    public static final int MY_CONST1 = 1;
}
// rest of MyClass.java

Comments

क्या ये सच है? किसी को भी इस विधि के साथ कोई अनुभव है?

— स्कॉट बिग्स

Answer 7

class Myclass {

 companion object {
        const val MYCONSTANT = 479
}

आपके पास दो विकल्प हैं जो आप constकीवर्ड का उपयोग कर सकते हैं या इसका उपयोग कर सकते हैं @JvmFieldजो इसे एक जावा के स्थिर अंतिम स्थिर बनाता है।

class Myclass {

     companion object {
           @JvmField val MYCONSTANT = 479
    }

यदि आप @JvmFieldएनोटेशन का उपयोग करते हैं, तो यह संकलन करने के बाद आपके लिए निरंतर हो जाता है जिस तरह से आप इसे जावा में कहेंगे।
जैसे आप इसे जावा में कहते हैं, कंपाइलर आपके लिए जगह लेगा जब आप साथी को कोड में स्थिर कहते हैं।

हालाँकि, यदि आप कॉन्स्टेबल कीवर्ड का उपयोग करते हैं तो स्थिर का मान इनबिल्ट हो जाता है। इनलाइन से मेरा मतलब है कि वास्तविक मूल्य का उपयोग संकलन के बाद किया जाता है।

यहाँ संक्षेप में यह है कि संकलक आपके लिए क्या करेगा:

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

Answer 8

कोटलिन स्थिर और निरंतर मूल्य और विधि की घोषणा

object MyConstant {

@JvmField   // for access in java code 
val PI: Double = 3.14

@JvmStatic // JvmStatic annotation for access in java code
fun sumValue(v1: Int, v2: Int): Int {
    return v1 + v2
}

}

कहीं भी पहुंच मूल्य

val value = MyConstant.PI
val value = MyConstant.sumValue(10,5)

Comments

वैश्विक या स्थिर विधि को कैसे परिभाषित करें?

— समद तालुकदार

@SamadTalukder कोटलिन में यह मजेदार योग होगा (v1: Int, v2: Int): Int {वापसी v1 + v2}

— शोमू

Answer 9

जैसे val, constकीवर्ड के साथ परिभाषित चर अपरिवर्तनीय हैं। यहाँ अंतर यह है कि constसंकलन-समय पर ज्ञात चर के लिए उपयोग किया जाता है।

एक चर की घोषणा जावा में कीवर्ड constका उपयोग करने की तरह है static।

आइए देखें कि कोटलिन में एक कास्ट वैरिएबल कैसे घोषित किया जाए:

const val COMMUNITY_NAME = "wiki"

और जावा में लिखा गया अनुरूप कोड होगा:

final static String COMMUNITY_NAME = "wiki";

उपरोक्त उत्तरों में जोड़ना -

@JvmField कोटलिन कंपाइलर को निर्देश दिया जाता है कि वह इस संपत्ति के लिए गेटर्स / सेटर न बनाएं और इसे एक क्षेत्र के रूप में उजागर करें।

 @JvmField
 val COMMUNITY_NAME: "Wiki"

स्थैतिक क्षेत्र

किसी नामित ऑब्जेक्ट या साथी ऑब्जेक्ट में घोषित कोटलिन गुणों में स्थिर बैकिंग फ़ील्ड या तो उस नामित ऑब्जेक्ट में या क्लास में साथी ऑब्जेक्ट होगा।

आमतौर पर ये क्षेत्र निजी होते हैं लेकिन इन्हें निम्न तरीकों में से एक में उजागर किया जा सकता है:

• @JvmField एनोटेशन;
• lateinit संशोधक;
• const संशोधक।

अधिक विवरण यहाँ - https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#instance-fields

Answer 10

किसी भी उत्तर में उल्लेखित नहीं है कि कुछ का उपयोग करने के ऊपर है companion objects। जैसा कि आप यहाँ पढ़ सकते हैं , साथी वस्तुएँ वास्तव में वस्तुओं हैं और उन्हें बनाने से संसाधनों की खपत होती है। इसके अलावा, आपको हर बार जब आप अपने कॉन्स्टेंट का उपयोग करते हैं, तो आपको एक से अधिक गेट्टर फंक्शन से गुजरना पड़ सकता है। यदि आप की जरूरत है कि कुछ आदिम स्थिरांक है तो आप शायद valएक बेहतर प्रदर्शन प्राप्त करने और बचने के उपयोग से बेहतर होंगेcompanion object ।

टी एल; डॉ; लेख का:

साथी ऑब्जेक्ट का उपयोग करना वास्तव में इस कोड को बदल देता है

class MyClass {

    companion object {
        private val TAG = "TAG"
    }

    fun helloWorld() {
        println(TAG)
    }
}

इस कोड में:

public final class MyClass {
    private static final String TAG = "TAG";
    public static final Companion companion = new Companion();

    // synthetic
    public static final String access$getTAG$cp() {
        return TAG;
    }

    public static final class Companion {
        private final String getTAG() {
            return MyClass.access$getTAG$cp();
        }

        // synthetic
        public static final String access$getTAG$p(Companion c) {
            return c.getTAG();
        }
    }

    public final void helloWorld() {
        System.out.println(Companion.access$getTAG$p(companion));
    }
}

इसलिए इनसे बचने की कोशिश करें।

Answer 11

स्थानीय स्थिरांक:

const val NAME = "name"

वैश्विक स्थिरांक:

object MyConstants{
    val NAME = "name"
    val ID = "_id"
    var EMAIL = "email"
}

MyConstants.NAME को एक्सेस करें

Answer 12

कोटलिन में स्थिरांक को परिभाषित करने के कुछ तरीके हैं,

साथी वस्तु का उपयोग करना

    companion object {
        const val ITEM1 = "item1"
        const val ITEM2 = "item2"
    }

आप किसी भी वर्ग के अंदर साथी ऑब्जेक्ट ब्लॉक से ऊपर का उपयोग कर सकते हैं और इस ब्लॉक के अंदर अपने सभी क्षेत्रों को परिभाषित कर सकते हैं। लेकिन इस दृष्टिकोण के साथ एक समस्या है, प्रलेखन कहता है,

भले ही साथी वस्तुओं के सदस्य अन्य भाषाओं में स्थिर सदस्यों की तरह दिखते हैं, पर रनटाइम में वे अभी भी वास्तविक वस्तुओं के सदस्य हैं, और उदाहरण के लिए, इंटरफेस को लागू कर सकते हैं।

जब आप साथी ऑब्जेक्ट का उपयोग करके अपने स्थिरांक बनाते हैं, और विघटित बायोटेक को देखते हैं , तो आप नीचे कुछ पसंद करेंगे,

  ClassName.Companion Companion = ClassName.Companion.$$INSTANCE;
  @NotNull
  String ITEM1 = "item1";
  @NotNull
  String ITEM2 = "item2";

  public static final class Companion {
     @NotNull
     private static final String ITEM1 = "item1";
     @NotNull
     public static final String ITEM2 = "item2";

     // $FF: synthetic field
     static final ClassName.Companion $$INSTANCE;

     private Companion() {
     }

     static {
        ClassName.Companion var0 = new ClassName.Companion();
        $$INSTANCE = var0;
     }
  }

यहाँ से आप आसानी से देख सकते हैं कि दस्तावेज़ीकरण में क्या कहा गया है, भले ही साथी वस्तुओं के सदस्य अन्य भाषाओं में स्थिर सदस्यों की तरह दिखते हों, पर वे अभी भी वास्तविक वस्तुओं के सदस्य हैं। यह आवश्यक से अतिरिक्त काम कर रहा है।

अब एक और तरीका आता है, जहाँ हमें नीचे की तरह साथी ऑब्जेक्ट का उपयोग करने की आवश्यकता नहीं है ,

object ApiConstants {
      val ITEM1: String = "item1"
 }

यदि आप ऊपर स्निपेट के बाइट कोड के विघटित संस्करण को देखते हैं, तो आपको कुछ इस तरह मिलेगा,

public final class ApiConstants {
     private static final String ITEM1 = "item1";

     public static final ApiConstants INSTANCE;

     public final String getITEM1() {
           return ITEM1;
      }

     private ApiConstants() {
      }

     static {
         ApiConstants var0 = new ApiConstants();
         INSTANCE = var0;
         CONNECT_TIMEOUT = "item1";
      }
    }

अब यदि आप उपरोक्त विघटित कोड देखते हैं, तो यह प्रत्येक चर के लिए विधि प्राप्त कर रहा है। इस विधि की आवश्यकता नहीं है।

इन get तरीकों में से छुटकारा पाने के लिए , आप का उपयोग करना चाहिए स्थिरांक से पहले वैल से नीचे की तरह,

object ApiConstants {
     const val ITEM1: String = "item1"
 }

अब यदि आप ऊपर स्निपेट का डिकम्पोज्ड कोड देखते हैं, तो आपको पढ़ना आसान लगेगा क्योंकि यह आपके कोड के लिए कम से कम पृष्ठभूमि रूपांतरण करता है।

public final class ApiConstants {
    public static final String ITEM1 = "item1";
    public static final ApiConstants INSTANCE;

    private ApiConstants() {
     }

    static {
        ApiConstants var0 = new ApiConstants();
        INSTANCE = var0;
      }
    }

तो यह स्थिरांक बनाने का सबसे अच्छा तरीका है।

Answer 13

आदिम और स्ट्रिंग्स के लिए:

/** The empty String. */
const val EMPTY_STRING = ""

अन्य मामलों के लिए:

/** The empty array of Strings. */
@JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)

उदाहरण:

/*
 * Copyright 2018 Vorlonsoft LLC
 *
 * Licensed under The MIT License (MIT)
 */

package com.vorlonsoft.android.rate

import com.vorlonsoft.android.rate.Constants.Utils.Companion.UTILITY_CLASS_MESSAGE

/**
 * Constants Class - the constants class of the AndroidRate library.
 *
 * @constructor Constants is a utility class and it can't be instantiated.
 * @since       1.1.8
 * @version     1.2.1
 * @author      Alexander Savin
 */
internal class Constants private constructor() {
    /** Constants Class initializer block. */
    init {
        throw UnsupportedOperationException("Constants$UTILITY_CLASS_MESSAGE")
    }

    /**
     * Constants.Date Class - the date constants class of the AndroidRate library.
     *
     * @constructor Constants.Date is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Date private constructor() {
        /** Constants.Date Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Date$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains date constants. */
        companion object {
            /** The time unit representing one year in days. */
            const val YEAR_IN_DAYS = 365.toShort()
        }
    }

    /**
     * Constants.Utils Class - the utils constants class of the AndroidRate library.
     *
     * @constructor Constants.Utils is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Utils private constructor() {
        /** Constants.Utils Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Utils$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains utils constants. */
        companion object {
            /** The empty String. */
            const val EMPTY_STRING = ""
            /** The empty array of Strings. */
            @JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)
            /** The part 2 of a utility class unsupported operation exception message. */
            const val UTILITY_CLASS_MESSAGE = " is a utility class and it can't be instantiated!"
        }
    }
}